procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Alex Samuel <samuel@codesourcery.com>

Browse source 
* ggc.h (rtvec_def): Forward declare.
        (tree_node): Likewise.
        (ggc_root): Define.
        (roots): Declare.
        (ggc_set_mark_rtx): Add prototype.
        (ggc_set_mark_rtvec): Likewise.
        (ggc_set_mark_tree): Likewise.
        * ggc-simple.c (ggc_root): Don't define.
        (roots): Don't declare.
        (ggc_mark_rtx): Remove.
        (ggc_mark_rtvec): Likewise.
        (ggc_mark_tree): Likewise.
        (ggc_mark_varray): Likewise.
        (ggc_mark_tree_hash_table_entry): Likewise.
        (ggc_mark_tree_hash_table): Likewise.
        (ggc_set_mart_rtx): New function.
        (ggc_set_mark_rtvec): Likewise.
        (ggc_set_mark_tree): Likewise.
        (ggc_add_root): Remove.
        (ggc_add_rtx_root): Likewise.
        (ggc_remove_tree_root): Likewise.
        (ggc_add_string_root): Likewise.
        (ggc_add_tree_varray_root): Likewise.
        (ggc_add_tree_hash_table_root): Likewise.
        (ggc_del_root): Likewise.
        (ggc_mark_rtx_ptr): Likewise.
        (ggc_mark_tree_ptr): Likewise.
        (ggc_mark_string_ptr): Likewise.
        (ggc_mark_tree_varray_ptr): Likewise.
        (ggc_mark_tree_hash_table_ptr): Likewise.
        * ggc-common.c: New file.
        * Makefile.in (OBJS): Add ggc-common.o.
        (ggc-common.o): List dependencies.

From-SVN: r29281
This commit is contained in:
Alex Samuel 1999-09-11 19:48:37 +00:00 • committed by Richard Henderson
parent 61efc8c246
commit b49a6a907c
5 changed files with 527 additions and 414 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
gcc/ChangeLog
View file

@ -1,3 +1,39 @@
Sat Sep 11 12:41:55 1999 Alex Samuel <samuel@codesourcery.com>
* ggc.h (rtvec_def): Forward declare.
(tree_node): Likewise.
(ggc_root): Define.
(roots): Declare.
(ggc_set_mark_rtx): Add prototype.
(ggc_set_mark_rtvec): Likewise.
(ggc_set_mark_tree): Likewise.
* ggc-simple.c (ggc_root): Don't define.
(roots): Don't declare.
(ggc_mark_rtx): Remove.
(ggc_mark_rtvec): Likewise.
(ggc_mark_tree): Likewise.
(ggc_mark_varray): Likewise.
(ggc_mark_tree_hash_table_entry): Likewise.
(ggc_mark_tree_hash_table): Likewise.
(ggc_set_mart_rtx): New function.
(ggc_set_mark_rtvec): Likewise.
(ggc_set_mark_tree): Likewise.
(ggc_add_root): Remove.
(ggc_add_rtx_root): Likewise.
(ggc_remove_tree_root): Likewise.
(ggc_add_string_root): Likewise.
(ggc_add_tree_varray_root): Likewise.
(ggc_add_tree_hash_table_root): Likewise.
(ggc_del_root): Likewise.
(ggc_mark_rtx_ptr): Likewise.
(ggc_mark_tree_ptr): Likewise.
(ggc_mark_string_ptr): Likewise.
(ggc_mark_tree_varray_ptr): Likewise.
(ggc_mark_tree_hash_table_ptr): Likewise.
* ggc-common.c: New file.
* Makefile.in (OBJS): Add ggc-common.o.
(ggc-common.o): List dependencies.
1999-09-10 22:37 -0700 Zack Weinberg <zack@bitmover.com>
* cppalloc.c (xstrdup): Use memcpy.

5
gcc/Makefile.in
View file

@ -675,7 +675,7 @@ OBJS = toplev.o version.o tree.o print-tree.o stor-layout.o fold-const.o \
insn-opinit.o insn-recog.o insn-extract.o insn-output.o insn-emit.o lcm.o \
profile.o insn-attrtab.o $(out_object_file) $(EXTRA_OBJS) convert.o \
mbchar.o dyn-string.o splay-tree.o graph.o sbitmap.o resource.o hash.o \
lists.o $(GGC)
lists.o ggc-common.o $(GGC)
# GEN files are listed separately, so they can be built before doing parallel
# makes for cc1 or cc1plus. Otherwise sequent parallel make attempts to load
@ -1445,6 +1445,9 @@ dumpvers: dumpvers.c
version.o: version.c
ggc-common.o: ggc-common.c $(CONFIG_H) $(RTL_BASE_H) $(TREE_H) \
flags.h ggc.h varray.h hash.h
ggc-simple.o: ggc-simple.c $(CONFIG_H) $(RTL_BASE_H) $(TREE_H) flags.h \
ggc.h varray.h hash.h

417
gcc/ggc-common.c Normal file
View file

@ -0,0 +1,417 @@
/* Simple garbage collection for the GNU compiler.
Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC 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 2, or (at your option)
any later version.
GNU CC 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 GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Generic garbage collection (GC) functions and data, not specific to
any particular GC implementation. */
#include "config.h"
#include "system.h"
#include "ggc.h"
#include "hash.h"
#include "rtl.h"
#include "tree.h"
#include "varray.h"
/* Maintain global roots that are preserved during GC. */
struct ggc_root *roots;
/* Type-correct function to pass to ggc_add_root. It just forwards
*ELT (which is an rtx) to ggc_mark_tree_varray. */
static void
ggc_mark_rtx_ptr (elt)
void *elt;
{
ggc_mark_rtx (*(rtx *)elt);
}
/* Type-correct function to pass to ggc_add_root. It just forwards
*ELT (which is a tree) to ggc_mark_tree. */
static void
ggc_mark_tree_ptr (elt)
void *elt;
{
ggc_mark_tree (*(tree *)elt);
}
/* Type-correct function to pass to ggc_add_root. It just forwards
ELT (which is really a varray_type *) to ggc_mark_tree_varray. */
static void
ggc_mark_tree_varray_ptr (elt)
void *elt;
{
ggc_mark_tree_varray (*(varray_type *)elt);
}
/* Type-correct function to pass to ggc_add_root. It just forwards
ELT (which is really a struct hash_table **) to
ggc_mark_tree_hash_table. */
static void
ggc_mark_tree_hash_table_ptr (elt)
void *elt;
{
ggc_mark_tree_hash_table (*(struct hash_table **) elt);
}
static void
ggc_mark_string_ptr (elt)
void *elt;
{
ggc_mark_string (*(char **)elt);
}
void
ggc_add_root (base, nelt, size, cb)
void *base;
int nelt, size;
void (*cb) PROTO ((void *));
{
struct ggc_root *x = (struct ggc_root *) xmalloc (sizeof (*x));
x->next = roots;
x->base = base;
x->nelt = nelt;
x->size = size;
x->cb = cb;
roots = x;
}
void
ggc_add_rtx_root (base, nelt)
rtx *base;
int nelt;
{
ggc_add_root (base, nelt, sizeof(rtx), ggc_mark_rtx_ptr);
}
void
ggc_add_tree_root (base, nelt)
tree *base;
int nelt;
{
ggc_add_root (base, nelt, sizeof(tree), ggc_mark_tree_ptr);
}
/* Add V (a varray full of trees) to the list of GC roots. */
void
ggc_add_tree_varray_root (base, nelt)
varray_type *base;
int nelt;
{
ggc_add_root (base, nelt, sizeof (varray_type),
ggc_mark_tree_varray_ptr);
}
/* Add HT (a hash-table where ever key is a tree) to the list of GC
roots. */
void
ggc_add_tree_hash_table_root (base, nelt)
struct hash_table **base;
int nelt;
{
ggc_add_root (base, nelt, sizeof (struct hash_table *),
ggc_mark_tree_hash_table_ptr);
}
void
ggc_add_string_root (base, nelt)
char **base;
int nelt;
{
ggc_add_root (base, nelt, sizeof (char *), ggc_mark_string_ptr);
}
void
ggc_del_root (base)
void *base;
{
struct ggc_root *x, **p;
p = &roots, x = roots;
while (x)
{
if (x->base == base)
{
*p = x->next;
free (x);
return;
}
p = &x->next;
x = x->next;
}
abort();
}
void
ggc_mark_rtx (r)
rtx r;
{
const char *fmt;
int i;
if (r == NULL_RTX || ggc_set_mark_rtx (r))
return;
/* ??? If (some of) these are really pass-dependant info, do we have
any right poking our noses in? */
switch (GET_CODE (r))
{
case JUMP_INSN:
ggc_mark_rtx (JUMP_LABEL (r));
break;
case CODE_LABEL:
ggc_mark_rtx (LABEL_REFS (r));
break;
case LABEL_REF:
ggc_mark_rtx (LABEL_NEXTREF (r));
ggc_mark_rtx (CONTAINING_INSN (r));
break;
case ADDRESSOF:
ggc_mark_tree (ADDRESSOF_DECL (r));
break;
case CONST_DOUBLE:
ggc_mark_rtx (CONST_DOUBLE_CHAIN (r));
break;
case NOTE:
switch (NOTE_LINE_NUMBER (r))
{
case NOTE_INSN_RANGE_START:
case NOTE_INSN_RANGE_END:
case NOTE_INSN_LIVE:
ggc_mark_rtx (NOTE_RANGE_INFO (r));
break;
default:
if (NOTE_LINE_NUMBER (r) >= 0)
ggc_mark_string (NOTE_SOURCE_FILE (r));
break;
}
break;
default:
break;
}
for (fmt = GET_RTX_FORMAT (GET_CODE (r)), i = 0; *fmt ; ++fmt, ++i)
{
switch (*fmt)
{
case 'e': case 'u':
ggc_mark_rtx (XEXP (r, i));
break;
case 'V': case 'E':
ggc_mark_rtvec (XVEC (r, i));
break;
case 'S': case 's':
ggc_mark_string (XSTR (r, i));
break;
}
}
}
void
ggc_mark_rtvec (v)
rtvec v;
{
int i;
if (v == NULL || ggc_set_mark_rtvec (v))
return;
i = GET_NUM_ELEM (v);
while (--i >= 0)
ggc_mark_rtx (RTVEC_ELT (v, i));
}
void
ggc_mark_tree (t)
tree t;
{
/* FIXME what if t == NULL_TREE ? */
if (t == NULL || ggc_set_mark_tree (t))
return;
/* Bits from common. */
ggc_mark_tree (TREE_TYPE (t));
ggc_mark_tree (TREE_CHAIN (t));
/* Some nodes require special handling. */
switch (TREE_CODE (t))
{
case TREE_LIST:
ggc_mark_tree (TREE_PURPOSE (t));
ggc_mark_tree (TREE_VALUE (t));
return;
case TREE_VEC:
{
int i = TREE_VEC_LENGTH (t);
while (--i >= 0)
ggc_mark_tree (TREE_VEC_ELT (t, i));
return;
}
case SAVE_EXPR:
ggc_mark_tree (TREE_OPERAND (t, 0));
ggc_mark_tree (SAVE_EXPR_CONTEXT (t));
ggc_mark_rtx (SAVE_EXPR_RTL (t));
return;
case RTL_EXPR:
ggc_mark_rtx (RTL_EXPR_SEQUENCE (t));
ggc_mark_rtx (RTL_EXPR_RTL (t));
return;
case CALL_EXPR:
ggc_mark_tree (TREE_OPERAND (t, 0));
ggc_mark_tree (TREE_OPERAND (t, 1));
ggc_mark_rtx (CALL_EXPR_RTL (t));
return;
case COMPLEX_CST:
ggc_mark_tree (TREE_REALPART (t));
ggc_mark_tree (TREE_IMAGPART (t));
break;
case STRING_CST:
ggc_mark_string (TREE_STRING_POINTER (t));
break;
case PARM_DECL:
ggc_mark_rtx (DECL_INCOMING_RTL (t));
break;
case IDENTIFIER_NODE:
ggc_mark_string (IDENTIFIER_POINTER (t));
lang_mark_tree (t);
return;
default:
break;
}
/* But in general we can handle them by class. */
switch (TREE_CODE_CLASS (TREE_CODE (t)))
{
case 'd': /* A decl node. */
ggc_mark_tree (DECL_SIZE (t));
ggc_mark_tree (DECL_NAME (t));
ggc_mark_tree (DECL_CONTEXT (t));
ggc_mark_tree (DECL_ARGUMENTS (t));
ggc_mark_tree (DECL_RESULT (t));
ggc_mark_tree (DECL_INITIAL (t));
ggc_mark_tree (DECL_ABSTRACT_ORIGIN (t));
ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
ggc_mark_tree (DECL_SECTION_NAME (t));
ggc_mark_tree (DECL_MACHINE_ATTRIBUTES (t));
ggc_mark_rtx (DECL_RTL (t));
ggc_mark_tree (DECL_VINDEX (t));
lang_mark_tree (t);
break;
case 't': /* A type node. */
ggc_mark_tree (TYPE_SIZE (t));
ggc_mark_tree (TYPE_SIZE_UNIT (t));
ggc_mark_tree (TYPE_ATTRIBUTES (t));
ggc_mark_tree (TYPE_VALUES (t));
ggc_mark_tree (TYPE_POINTER_TO (t));
ggc_mark_tree (TYPE_REFERENCE_TO (t));
ggc_mark_tree (TYPE_NAME (t));
ggc_mark_tree (TYPE_MIN_VALUE (t));
ggc_mark_tree (TYPE_MAX_VALUE (t));
ggc_mark_tree (TYPE_NEXT_VARIANT (t));
ggc_mark_tree (TYPE_MAIN_VARIANT (t));
ggc_mark_tree (TYPE_BINFO (t));
ggc_mark_tree (TYPE_NONCOPIED_PARTS (t));
ggc_mark_tree (TYPE_CONTEXT (t));
lang_mark_tree (t);
break;
case 'b': /* A lexical block. */
ggc_mark_tree (BLOCK_VARS (t));
ggc_mark_tree (BLOCK_TYPE_TAGS (t));
ggc_mark_tree (BLOCK_SUBBLOCKS (t));
ggc_mark_tree (BLOCK_SUPERCONTEXT (t));
ggc_mark_tree (BLOCK_ABSTRACT_ORIGIN (t));
ggc_mark_rtx (BLOCK_END_NOTE (t));
break;
case 'c': /* A constant. */
ggc_mark_rtx (TREE_CST_RTL (t));
break;
case 'r': case '<': case '1':
case '2': case 'e': case 's': /* Expressions. */
{
int i = tree_code_length[TREE_CODE (t)];
while (--i >= 0)
ggc_mark_tree (TREE_OPERAND (t, i));
break;
}
case 'x':
lang_mark_tree (t);
break;
}
}
/* Mark all the elements of the varray V, which contains trees. */
void
ggc_mark_tree_varray (v)
varray_type v;
{
int i;
if (v)
for (i = v->num_elements - 1; i >= 0; --i)
ggc_mark_tree (VARRAY_TREE (v, i));
}
/* Mark the hash table-entry HE. It's key field is really a tree. */
static boolean
ggc_mark_tree_hash_table_entry (he, k)
struct hash_entry *he;
hash_table_key k ATTRIBUTE_UNUSED;
{
ggc_mark_tree ((tree) he->key);
return true;
}
/* Mark all the elements of the hash-table H, which contains trees. */
void
ggc_mark_tree_hash_table (ht)
struct hash_table *ht;
{
hash_traverse (ht, ggc_mark_tree_hash_table_entry, /*info=*/0);
}

408
gcc/ggc-simple.c
View file

@ -50,17 +50,6 @@
/* Global lists of roots, rtxs, and trees. */
struct ggc_root
{
struct ggc_root *next;
void *base;
int nelt;
int size;
void (*cb) PROTO ((void *));
};
static struct ggc_root *roots;
struct ggc_rtx
{
struct ggc_rtx *chain;
@ -137,14 +126,6 @@ static void ggc_free_tree PROTO ((struct ggc_tree *t));
static void ggc_free_string PROTO ((struct ggc_string *s));
static void ggc_free_any PROTO ((struct ggc_any *a));
static void ggc_mark_rtx_ptr PROTO ((void *elt));
static void ggc_mark_tree_ptr PROTO ((void *elt));
static void ggc_mark_string_ptr PROTO ((void *elt));
static void ggc_mark_tree_varray_ptr PROTO ((void *elt));
static void ggc_mark_tree_hash_table_ptr PROTO ((void *elt));
static boolean ggc_mark_tree_hash_table_entry PROTO ((struct hash_entry *,
hash_table_key));
/* Called once to initialize the garbage collector. */
void
@ -346,7 +327,7 @@ ggc_alloc (bytes)
/* Freeing a bit of rtl is as simple as calling free. */
static inline void
static inline void
ggc_free_rtx (r)
struct ggc_rtx *r;
{
@ -430,252 +411,34 @@ ggc_free_any (a)
/* Mark a node. */
void
ggc_mark_rtx (r)
int
ggc_set_mark_rtx (r)
rtx r;
{
const char *fmt;
int i;
if (r == NULL_RTX || r->gc_mark)
return;
r->gc_mark = 1;
/* ??? If (some of) these are really pass-dependant info, do we have
any right poking our noses in? */
switch (GET_CODE (r))
{
case JUMP_INSN:
ggc_mark_rtx (JUMP_LABEL (r));
break;
case CODE_LABEL:
ggc_mark_rtx (LABEL_REFS (r));
break;
case LABEL_REF:
ggc_mark_rtx (LABEL_NEXTREF (r));
ggc_mark_rtx (CONTAINING_INSN (r));
break;
case ADDRESSOF:
ggc_mark_tree (ADDRESSOF_DECL (r));
break;
case CONST_DOUBLE:
ggc_mark_rtx (CONST_DOUBLE_CHAIN (r));
break;
case NOTE:
switch (NOTE_LINE_NUMBER (r))
{
case NOTE_INSN_RANGE_START:
case NOTE_INSN_RANGE_END:
case NOTE_INSN_LIVE:
ggc_mark_rtx (NOTE_RANGE_INFO (r));
break;
default:
if (NOTE_LINE_NUMBER (r) >= 0)
ggc_mark_string (NOTE_SOURCE_FILE (r));
break;
}
break;
default:
break;
}
for (fmt = GET_RTX_FORMAT (GET_CODE (r)), i = 0; *fmt ; ++fmt, ++i)
{
switch (*fmt)
{
case 'e': case 'u':
ggc_mark_rtx (XEXP (r, i));
break;
case 'V': case 'E':
ggc_mark_rtvec (XVEC (r, i));
break;
case 'S': case 's':
ggc_mark_string (XSTR (r, i));
break;
}
}
int marked = r->gc_mark;
if (! marked)
r->gc_mark = 1;
return marked;
}
void
ggc_mark_rtvec (v)
int
ggc_set_mark_rtvec (v)
rtvec v;
{
int i;
if (v == NULL || v->gc_mark)
return;
v->gc_mark = 1;
i = GET_NUM_ELEM (v);
while (--i >= 0)
ggc_mark_rtx (RTVEC_ELT (v, i));
int marked = v->gc_mark;
if (! marked)
v->gc_mark = 1;
return marked;
}
void
ggc_mark_tree (t)
int
ggc_set_mark_tree (t)
tree t;
{
if (t == NULL_TREE || t->common.gc_mark)
return;
t->common.gc_mark = 1;
/* Bits from common. */
ggc_mark_tree (TREE_TYPE (t));
ggc_mark_tree (TREE_CHAIN (t));
/* Some nodes require special handling. */
switch (TREE_CODE (t))
{
case TREE_LIST:
ggc_mark_tree (TREE_PURPOSE (t));
ggc_mark_tree (TREE_VALUE (t));
return;
case TREE_VEC:
{
int i = TREE_VEC_LENGTH (t);
while (--i >= 0)
ggc_mark_tree (TREE_VEC_ELT (t, i));
return;
}
case SAVE_EXPR:
ggc_mark_tree (TREE_OPERAND (t, 0));
ggc_mark_tree (SAVE_EXPR_CONTEXT (t));
ggc_mark_rtx (SAVE_EXPR_RTL (t));
return;
case RTL_EXPR:
ggc_mark_rtx (RTL_EXPR_SEQUENCE (t));
ggc_mark_rtx (RTL_EXPR_RTL (t));
return;
case CALL_EXPR:
ggc_mark_tree (TREE_OPERAND (t, 0));
ggc_mark_tree (TREE_OPERAND (t, 1));
ggc_mark_rtx (CALL_EXPR_RTL (t));
return;
case COMPLEX_CST:
ggc_mark_tree (TREE_REALPART (t));
ggc_mark_tree (TREE_IMAGPART (t));
break;
case STRING_CST:
ggc_mark_string (TREE_STRING_POINTER (t));
break;
case PARM_DECL:
ggc_mark_rtx (DECL_INCOMING_RTL (t));
break;
case IDENTIFIER_NODE:
ggc_mark_string (IDENTIFIER_POINTER (t));
lang_mark_tree (t);
return;
default:
break;
}
/* But in general we can handle them by class. */
switch (TREE_CODE_CLASS (TREE_CODE (t)))
{
case 'd': /* A decl node. */
ggc_mark_tree (DECL_SIZE (t));
ggc_mark_tree (DECL_NAME (t));
ggc_mark_tree (DECL_CONTEXT (t));
ggc_mark_tree (DECL_ARGUMENTS (t));
ggc_mark_tree (DECL_RESULT (t));
ggc_mark_tree (DECL_INITIAL (t));
ggc_mark_tree (DECL_ABSTRACT_ORIGIN (t));
ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
ggc_mark_tree (DECL_SECTION_NAME (t));
ggc_mark_tree (DECL_MACHINE_ATTRIBUTES (t));
ggc_mark_rtx (DECL_RTL (t));
ggc_mark_tree (DECL_VINDEX (t));
lang_mark_tree (t);
break;
case 't': /* A type node. */
ggc_mark_tree (TYPE_SIZE (t));
ggc_mark_tree (TYPE_SIZE_UNIT (t));
ggc_mark_tree (TYPE_ATTRIBUTES (t));
ggc_mark_tree (TYPE_VALUES (t));
ggc_mark_tree (TYPE_POINTER_TO (t));
ggc_mark_tree (TYPE_REFERENCE_TO (t));
ggc_mark_tree (TYPE_NAME (t));
ggc_mark_tree (TYPE_MIN_VALUE (t));
ggc_mark_tree (TYPE_MAX_VALUE (t));
ggc_mark_tree (TYPE_NEXT_VARIANT (t));
ggc_mark_tree (TYPE_MAIN_VARIANT (t));
ggc_mark_tree (TYPE_BINFO (t));
ggc_mark_tree (TYPE_NONCOPIED_PARTS (t));
ggc_mark_tree (TYPE_CONTEXT (t));
lang_mark_tree (t);
break;
case 'b': /* A lexical block. */
ggc_mark_tree (BLOCK_VARS (t));
ggc_mark_tree (BLOCK_TYPE_TAGS (t));
ggc_mark_tree (BLOCK_SUBBLOCKS (t));
ggc_mark_tree (BLOCK_SUPERCONTEXT (t));
ggc_mark_tree (BLOCK_ABSTRACT_ORIGIN (t));
ggc_mark_rtx (BLOCK_END_NOTE (t));
break;
case 'c': /* A constant. */
ggc_mark_rtx (TREE_CST_RTL (t));
break;
case 'r': case '<': case '1':
case '2': case 'e': case 's': /* Expressions. */
{
int i = tree_code_length[TREE_CODE (t)];
while (--i >= 0)
ggc_mark_tree (TREE_OPERAND (t, i));
break;
}
case 'x':
lang_mark_tree (t);
break;
}
}
/* Mark all the elements of the varray V, which contains trees. */
void
ggc_mark_tree_varray (v)
varray_type v;
{
int i;
if (v)
for (i = v->num_elements - 1; i >= 0; --i)
ggc_mark_tree (VARRAY_TREE (v, i));
}
/* Mark the hash table-entry HE. It's key field is really a tree. */
static boolean
ggc_mark_tree_hash_table_entry (he, k)
struct hash_entry *he;
hash_table_key k ATTRIBUTE_UNUSED;
{
ggc_mark_tree ((tree) he->key);
return true;
}
/* Mark all the elements of the hash-table H, which contains trees. */
void
ggc_mark_tree_hash_table (ht)
struct hash_table *ht;
{
hash_traverse (ht, ggc_mark_tree_hash_table_entry, /*info=*/0);
int marked = t->common.gc_mark;
if (! marked)
t->common.gc_mark = 1;
return marked;
}
void
@ -883,139 +646,6 @@ ggc_collect ()
}
}
/* Manipulate global roots that are needed between calls to gc. */
void
ggc_add_root (base, nelt, size, cb)
void *base;
int nelt, size;
void (*cb) PROTO ((void *));
{
struct ggc_root *x = (struct ggc_root *) xmalloc (sizeof(*x));
x->next = roots;
x->base = base;
x->nelt = nelt;
x->size = size;
x->cb = cb;
roots = x;
}
void
ggc_add_rtx_root (base, nelt)
rtx *base;
int nelt;
{
ggc_add_root (base, nelt, sizeof(rtx), ggc_mark_rtx_ptr);
}
void
ggc_add_tree_root (base, nelt)
tree *base;
int nelt;
{
ggc_add_root (base, nelt, sizeof(tree), ggc_mark_tree_ptr);
}
void
ggc_add_string_root (base, nelt)
char **base;
int nelt;
{
ggc_add_root (base, nelt, sizeof(char *), ggc_mark_string_ptr);
}
/* Add V (a varray full of trees) to the list of GC roots. */
void
ggc_add_tree_varray_root (base, nelt)
varray_type *base;
int nelt;
{
ggc_add_root (base, nelt, sizeof (varray_type),
ggc_mark_tree_varray_ptr);
}
/* Add HT (a hash-table where ever key is a tree) to the list of GC
roots. */
void
ggc_add_tree_hash_table_root (base, nelt)
struct hash_table **base;
int nelt;
{
ggc_add_root (base, nelt, sizeof (struct hash_table *),
ggc_mark_tree_hash_table_ptr);
}
void
ggc_del_root (base)
void *base;
{
struct ggc_root *x, **p;
p = &roots, x = roots;
while (x)
{
if (x->base == base)
{
*p = x->next;
free (x);
return;
}
p = &x->next;
x = x->next;
}
abort();
}
static void
ggc_mark_rtx_ptr (elt)
void *elt;
{
ggc_mark_rtx (*(rtx *)elt);
}
static void
ggc_mark_tree_ptr (elt)
void *elt;
{
ggc_mark_tree (*(tree *)elt);
}
/* Type-correct function to pass to ggc_add_root. It just forwards
ELT (which is really a char **) to ggc_mark_string. */
static void
ggc_mark_string_ptr (elt)
void *elt;
{
ggc_mark_string (*(char **)elt);
}
/* Type-correct function to pass to ggc_add_root. It just forwards
ELT (which is really a varray_type *) to ggc_mark_tree_varray. */
static void
ggc_mark_tree_varray_ptr (elt)
void *elt;
{
ggc_mark_tree_varray (*(varray_type *)elt);
}
/* Type-correct function to pass to ggc_add_root. It just forwards
ELT (which is really a struct hash_table **) to
ggc_mark_tree_hash_table. */
static void
ggc_mark_tree_hash_table_ptr (elt)
void *elt;
{
ggc_mark_tree_hash_table (*(struct hash_table **) elt);
}
#if 0
/* GDB really should have a memory search function. Since this is just
for initial debugging, I won't even pretend to get the __data_start

75
gcc/ggc.h
View file

@ -31,37 +31,28 @@ extern int ggc_p;
compiler. However, rather than force everyone who includes this
header to include all the headers in which they are declared, we
just forward-declare them here. */
struct label_node;
struct eh_status;
struct emit_status;
struct hash_table;
struct label_node;
struct rtvec_def;
struct stmt_status;
union tree_node;
struct varasm_status;
struct varray_head_tag;
struct hash_table;
/* Startup */
/* Global roots that are preserved during calls to gc. */
extern void init_ggc PROTO ((void));
struct ggc_root
{
struct ggc_root *next;
void *base;
int nelt;
int size;
void (*cb) PROTO ((void *));
};
/* Start a new GGC context. Memory allocated in previous contexts
will not be collected while the new context is active. */
extern void ggc_pop_context PROTO ((void));
/* Finish a GC context. Any uncollected memory in the new context
will be merged with the old context. */
extern void ggc_push_context PROTO ((void));
/* Allocation. */
struct rtx_def *ggc_alloc_rtx PROTO ((int nslots));
struct rtvec_def *ggc_alloc_rtvec PROTO ((int nelt));
union tree_node *ggc_alloc_tree PROTO ((int length));
char *ggc_alloc_string PROTO ((const char *contents, int length));
void *ggc_alloc PROTO ((size_t));
/* Invoke the collector. This is really just a hint, but in the case of
the simple collector, the only time it will happen. */
void ggc_collect PROTO ((void));
extern struct ggc_root *roots;
/* Manipulate global roots that are needed between calls to gc. */
void ggc_add_root PROTO ((void *base, int nelt, int size, void (*)(void *)));
@ -72,7 +63,8 @@ void ggc_add_tree_varray_root PROTO ((struct varray_head_tag **, int nelt));
void ggc_add_tree_hash_table_root PROTO ((struct hash_table **, int nelt));
void ggc_del_root PROTO ((void *base));
/* Mark nodes from the gc_add_root callback. */
/* Mark nodes from the gc_add_root callback. These functions follow
pointers to mark other objects too. */
void ggc_mark_rtx PROTO ((struct rtx_def *));
void ggc_mark_rtvec PROTO ((struct rtvec_def *));
void ggc_mark_tree PROTO ((union tree_node *));
@ -81,6 +73,41 @@ void ggc_mark_tree_hash_table PROTO ((struct hash_table *));
void ggc_mark_string PROTO ((char *));
void ggc_mark PROTO ((void *));
/* A GC implementation must provide these functions. */
/* Initialize the garbage collector. */
extern void init_ggc PROTO ((void));
/* Start a new GGC context. Memory allocated in previous contexts
will not be collected while the new context is active. */
extern void ggc_pop_context PROTO ((void));
/* Finish a GC context. Any uncollected memory in the new context
will be merged with the old context. */
extern void ggc_push_context PROTO ((void));
/* Allocation. */
struct rtx_def *ggc_alloc_rtx PROTO ((int nslots));
struct rtvec_def *ggc_alloc_rtvec PROTO ((int nelt));
union tree_node *ggc_alloc_tree PROTO ((int length));
char *ggc_alloc_string PROTO ((const char *contents, int length));
void *ggc_alloc PROTO ((size_t));
/* Invoke the collector. This is really just a hint, but in the case of
the simple collector, the only time it will happen. */
void ggc_collect PROTO ((void));
/* Actually set the mark on a particular region of memory, but don't
follow pointers. These functions are called by ggc_mark_*. They
return zero if the object was not previously marked; they return
non-zero if the object was already marked, or if, for any other
reason, pointers in this data structure should not be traversed. */
int ggc_set_mark_rtx PROTO ((struct rtx_def *));
int ggc_set_mark_rtvec PROTO ((struct rtvec_def *));
int ggc_set_mark_tree PROTO ((union tree_node *));
/* Callbacks to the languages. */
/* This is the language's opportunity to mark nodes held through