This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Patch: Don't clear memory returned by ggc_alloc
On Wed, Jun 07, 2000 at 05:18:35PM -0700, Mark Mitchell wrote:
> >>>>> "Zack" == Zack Weinberg <zack@wolery.cumb.org> writes:
>
> Zack> If you profile cc1 on a file that doesn't hit any of the
> Zack> nonlinear bottlenecks, you'll see us spending from 5-10% of
> Zack> runtime in memset(). We call it millions of times, mostly
> Zack> from ggc_alloc_obj. But the memory blocks returned by
> Zack> ggc_alloc_obj are almost always going to be initialized
> Zack> thoroughly - by gen_rtx_fmt_xyz, or build, or whatever - so
> Zack> clearing the memory is a pure waste of time.
>
> I like the idea of this patch. But, I'd prefer to keep both entry
> points; like `calloc', `gcc_alloc_obj' has it's uses! So, I think it
> would be better if the places that are going to clear the memory
> explicitly used the `malloc'-like interface, but the other places
> continued to use the `calloc'-like interface.
This is a fair point. I've called the calloc-like entry point
`ggc_alloc_cleared', which makes it clear what it does and avoids the
test in the allocation fast path. Also, it only needs to be
implemented once. An updated patch is at the end of the message. You
can see that the changes to C++ are much smaller.
> Also, we'll have to figure out what's up with those C++ test failures
> before you check in the patch. :-)
With your suggestion for VOID_TYPE_P applied to my tree, and Jakub's
patch for make_thunk, I see only these C++ test failures:
XPASS: g++.brendan/parse4.C - referenced below (test for bogus messages, line 15)
FAIL: g++.ext/instantiate1.C not instantiated (test for errors, line 18)
FAIL: g++.ext/instantiate1.C not instantiated (test for errors, line 20)
FAIL: g++.law/operators24.C caused compiler crash
FAIL: g++.pt/nttp1.C caused compiler crash
FAIL: g++.pt/nttp2.C caused compiler crash
I haven't looked at parse4 or instantiate1. operators24 is the same
crash I reported the other day - it seems that your change to pushdecl
wasn't adequate to fix the bug. nttp[12].C are a related problem. GC
encounters a decl with no name:
<template_decl 0x40104400
type <template_template_parm 0x40104480 VOID
align 1 symtab 0 alias set 0
index 0 level 2 orig_level 2
chain <template_decl 0x40104400>>
decl_0 VOID file g++.pt/nttp1.C line 3
align 1
arguments <tree_list 0x400fefa0
purpose <integer_cst 0x400fef80 constant 0x300000000>
value <tree_vec 0x400fef60
elt 0 <tree_list 0x400fef40>>>
result <type_decl 0x40104380 type <template_template_parm 0x40104480>
VOID file g++.pt/nttp1.C line 3
align 1>
>
Line 3 of nttp1.C is
template <template<template <class> class> class TTT> struct C
and I would guess that this is the decl of one of the nested
templates. Anyway, in lang_mark_tree, DECL_OVERLOADED_OPERATOR_P()
tries to dereference t->decl.name which is NULL, so we crash.
I don't like the way the flag tested by DECL_OVERLOADED_OPERATOR_P is
stored in the identifier_node while the union it controls is stored in
the lang_decl. It is far too easy for them to get out of sync.
Incidentally, if you want to do --enable-checking=gcac bootstraps
yourself, I'd suggest editing the makefile so that both CFLAGS and
BOOT_CFLAGS contain -O (not -O2). That cuts four hours off the build
time for me.
zw
===================================================================
Index: c-typeck.c
--- c-typeck.c 2000/06/06 06:55:35 1.70
+++ c-typeck.c 2000/06/08 21:56:14
@@ -5595,7 +5595,7 @@ add_pending_init (purpose, value)
}
}
- r = (struct init_node *) ggc_alloc_obj (sizeof (struct init_node), 0);
+ r = (struct init_node *) ggc_alloc (sizeof (struct init_node));
r->purpose = purpose;
r->value = value;
===================================================================
Index: emit-rtl.c
--- emit-rtl.c 2000/05/26 01:49:38 1.134
+++ emit-rtl.c 2000/06/08 21:56:14
@@ -4125,6 +4125,7 @@ init_emit_once (line_numbers)
bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
CONST_DOUBLE_MEM (tem) = cc0_rtx;
+ CONST_DOUBLE_CHAIN (tem) = NULL_RTX;
PUT_MODE (tem, mode);
const_tiny_rtx[i][(int) mode] = tem;
===================================================================
Index: gengenrtl.c
--- gengenrtl.c 2000/04/21 19:09:18 1.34
+++ gengenrtl.c 2000/06/08 21:56:14
@@ -272,7 +272,7 @@ genmacro (idx)
if (*p != '0')
printf (", (ARG%d)", i++);
- printf (")\n");
+ puts (")");
}
/* Generate the code for the function to generate RTL whose
@@ -293,30 +293,31 @@ gendef (format)
if (*p != '0')
printf (", arg%d", i++);
- printf (")\n RTX_CODE code;\n enum machine_mode mode;\n");
+ puts (")\n RTX_CODE code;\n enum machine_mode mode;");
for (p = format, i = 0; *p != 0; p++)
if (*p != '0')
printf (" %sarg%d;\n", type_from_format (*p), i++);
/* Now write out the body of the function itself, which allocates
the memory and initializes it. */
- printf ("{\n");
- printf (" rtx rt;\n");
- printf (" if (ggc_p)\n");
- printf (" rt = ggc_alloc_rtx (%d);\n",
- (int) strlen (format));
- printf (" else\n");
- printf (" rt = obstack_alloc_rtx (sizeof (struct rtx_def) + %d * sizeof (rtunion));\n",
- (int) strlen (format) - 1);
+ puts ("{");
+ puts (" rtx rt;");
+ puts (" if (ggc_p)");
+ printf (" rt = ggc_alloc_rtx (%d);\n", (int) strlen (format));
+ puts (" else");
+ printf (" rt = obstack_alloc_rtx (%d);\n", (int) strlen (format));
+
+ puts (" memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));\n");
+ puts (" PUT_CODE (rt, code);");
+ puts (" PUT_MODE (rt, mode);");
- printf (" PUT_CODE (rt, code);\n");
- printf (" PUT_MODE (rt, mode);\n");
-
for (p = format, i = j = 0; *p ; ++p, ++i)
if (*p != '0')
printf (" %s (rt, %d) = arg%d;\n", accessor_from_format (*p), i, j++);
+ else
+ printf (" X0EXP (rt, %d) = NULL_RTX;\n", i);
- printf ("\n return rt;\n}\n\n");
+ puts ("\n return rt;\n}\n");
}
/* Generate the documentation header for files we write. */
@@ -324,8 +325,7 @@ gendef (format)
static void
genlegend ()
{
- printf ("/* Generated automatically by the program `gengenrtl'\n");
- printf (" from the RTL description file `rtl.def' */\n\n");
+ puts ("/* Generated automatically by gengenrtl from rtl.def. */\n");
}
/* Generate the text of the header file we make, genrtl.h. */
@@ -339,7 +339,7 @@ genheader ()
for (fmt = formats; *fmt; ++fmt)
gendecl (*fmt);
- printf ("\n");
+ putchar ('\n');
for (i = 0; i < NUM_RTX_CODE; i++)
if (! special_format (defs[i].format))
@@ -353,19 +353,16 @@ gencode ()
{
const char **fmt;
- puts ("#include \"config.h\"\n");
- puts ("#include \"system.h\"\n");
- puts ("#include \"obstack.h\"\n");
- puts ("#include \"rtl.h\"\n");
- puts ("#include \"ggc.h\"\n\n");
- puts ("extern struct obstack *rtl_obstack;\n\n");
- puts ("static rtx obstack_alloc_rtx PARAMS ((int length));\n");
- puts ("static rtx\n");
- puts ("obstack_alloc_rtx (length)\n");
- puts (" register int length;\n{\n");
- puts (" rtx rt = (rtx) obstack_alloc (rtl_obstack, length);\n\n");
- puts (" memset(rt, 0, sizeof(struct rtx_def) - sizeof(rtunion));\n\n");
- puts (" return rt;\n}\n\n");
+ puts ("#include \"config.h\"");
+ puts ("#include \"system.h\"");
+ puts ("#include \"obstack.h\"");
+ puts ("#include \"rtl.h\"");
+ puts ("#include \"ggc.h\"\n");
+ puts ("extern struct obstack *rtl_obstack;\n");
+ puts ("#define obstack_alloc_rtx(n) \\");
+ puts (" ((rtx) obstack_alloc (rtl_obstack, \\");
+ puts (" sizeof (struct rtx_def) \\");
+ puts (" + ((n) - 2) * sizeof (rtunion)))\n");
for (fmt = formats; *fmt != 0; fmt++)
gendef (*fmt);
===================================================================
Index: ggc-common.c
--- ggc-common.c 2000/05/27 15:21:15 1.28
+++ ggc-common.c 2000/06/08 21:56:15
@@ -580,12 +580,22 @@ ggc_alloc_string (contents, length)
length = strlen (contents);
}
- string = (char *) ggc_alloc_obj (length + 1, 0);
+ string = (char *) ggc_alloc (length + 1);
if (contents != NULL)
memcpy (string, contents, length);
string[length] = 0;
return string;
+}
+
+/* Allocate a block of memory, then clear it. */
+void *
+ggc_alloc_cleared (size)
+ size_t size;
+{
+ void *buf = ggc_alloc (size);
+ memset (buf, 0, size);
+ return buf;
}
/* Print statistics that are independent of the collector in use. */
===================================================================
Index: ggc-none.c
--- ggc-none.c 1999/10/13 17:09:18 1.7
+++ ggc-none.c 2000/06/08 21:56:15
@@ -36,12 +36,8 @@
int ggc_p = 0;
void *
-ggc_alloc_obj (size, zero)
+ggc_alloc (size)
size_t size;
- int zero;
{
- void *p = xmalloc (size);
- if (zero)
- memset (p, 0, size);
- return p;
+ return xmalloc (size);
}
===================================================================
Index: ggc-page.c
--- ggc-page.c 2000/04/28 00:59:39 1.26
+++ ggc-page.c 2000/06/08 21:56:15
@@ -611,9 +611,8 @@ static unsigned char const size_lookup[2
memory is zeroed; otherwise, its contents are undefined. */
void *
-ggc_alloc_obj (size, zero)
+ggc_alloc (size)
size_t size;
- int zero;
{
unsigned order, word, bit, object_offset;
struct page_entry *entry;
@@ -703,13 +702,10 @@ ggc_alloc_obj (size, zero)
result = entry->page + object_offset;
#ifdef GGC_POISON
- /* `Poison' the entire allocated object before zeroing the requested area,
- so that bytes beyond the end, if any, will not necessarily be zero. */
+ /* `Poison' the entire allocated object, including any padding at
+ the end. */
memset (result, 0xaf, 1 << order);
#endif
-
- if (zero)
- memset (result, 0, size);
/* Keep track of how many bytes are being allocated. This
information is used in deciding when to collect. */
===================================================================
Index: ggc-simple.c
--- ggc-simple.c 2000/05/12 17:07:02 1.33
+++ ggc-simple.c 2000/06/08 21:56:15
@@ -182,9 +182,8 @@ tree_lookup (v)
/* Alloc SIZE bytes of GC'able memory. If ZERO, clear the memory. */
void *
-ggc_alloc_obj (size, zero)
+ggc_alloc (size)
size_t size;
- int zero;
{
struct ggc_mem *x;
@@ -195,11 +194,8 @@ ggc_alloc_obj (size, zero)
x->context = G.context;
x->size = size;
- if (zero)
- memset (&x->u, 0, size);
#ifdef GGC_POISON
- else
- memset (&x->u, 0xaf, size);
+ memset (&x->u, 0xaf, size);
#endif
tree_insert (x);
===================================================================
Index: ggc.h
--- ggc.h 2000/04/07 09:24:06 1.27
+++ ggc.h 2000/06/08 21:56:15
@@ -128,20 +128,19 @@ extern void ggc_pop_context PARAMS ((voi
/* Allocation. */
/* The internal primitive. */
-void *ggc_alloc_obj PARAMS ((size_t, int));
+void *ggc_alloc PARAMS ((size_t));
+/* Like ggc_alloc, but allocates cleared memory. */
+void *ggc_alloc_cleared PARAMS ((size_t));
-#define ggc_alloc_rtx(NSLOTS) \
- ((struct rtx_def *) ggc_alloc_obj (sizeof (struct rtx_def) \
- + ((NSLOTS) - 1) * sizeof (rtunion), 1))
+#define ggc_alloc_rtx(NSLOTS) \
+ ((struct rtx_def *) ggc_alloc (sizeof (struct rtx_def) \
+ + ((NSLOTS) - 1) * sizeof (rtunion)))
#define ggc_alloc_rtvec(NELT) \
- ((struct rtvec_def *) ggc_alloc_obj (sizeof (struct rtvec_def) \
- + ((NELT) - 1) * sizeof (rtx), 1))
+ ((struct rtvec_def *) ggc_alloc (sizeof (struct rtvec_def) \
+ + ((NELT) - 1) * sizeof (rtx)))
-#define ggc_alloc_tree(LENGTH) \
- ((union tree_node *) ggc_alloc_obj ((LENGTH), 1))
-
-#define ggc_alloc(SIZE) ggc_alloc_obj((SIZE), 0)
+#define ggc_alloc_tree(LENGTH) ((union tree_node *) ggc_alloc (LENGTH))
char *ggc_alloc_string PARAMS ((const char *contents, int length));
===================================================================
Index: rtl.c
--- rtl.c 2000/04/21 19:32:09 1.69
+++ rtl.c 2000/06/08 21:56:15
@@ -275,21 +275,15 @@ rtvec_alloc (n)
int n;
{
rtvec rt;
-
+
if (ggc_p)
rt = ggc_alloc_rtvec (n);
else
- {
- int i;
-
- rt = (rtvec) obstack_alloc (rtl_obstack,
- sizeof (struct rtvec_def)
- + (( n - 1) * sizeof (rtx)));
-
- /* clear out the vector */
- for (i = 0; i < n; i++)
- rt->elem[i] = 0;
- }
+ rt = (rtvec) obstack_alloc (rtl_obstack,
+ sizeof (struct rtvec_def)
+ + ((n - 1) * sizeof (rtx)));
+ /* clear out the vector */
+ memset (&rt->elem[0], 0, n * sizeof (rtx));
PUT_NUM_ELEM (rt, n);
return rt;
@@ -303,39 +297,20 @@ rtx_alloc (code)
RTX_CODE code;
{
rtx rt;
+ int n = GET_RTX_LENGTH (code);
if (ggc_p)
- rt = ggc_alloc_rtx (GET_RTX_LENGTH (code));
+ rt = ggc_alloc_rtx (n);
else
- {
- register struct obstack *ob = rtl_obstack;
- register int nelts = GET_RTX_LENGTH (code);
- register int length = sizeof (struct rtx_def)
- + (nelts - 1) * sizeof (rtunion);
-
- /* This function is called more than any other in GCC, so we
- manipulate the obstack directly.
-
- Even though rtx objects are word aligned, we may be sharing
- an obstack with tree nodes, which may have to be double-word
- aligned. So align our length to the alignment mask in the
- obstack. */
-
- length = (length + ob->alignment_mask) & ~ ob->alignment_mask;
-
- if (ob->chunk_limit - ob->next_free < length)
- _obstack_newchunk (ob, length);
- rt = (rtx)ob->object_base;
- ob->next_free += length;
- ob->object_base = ob->next_free;
-
- /* We want to clear everything up to the FLD array. Normally,
- this is one int, but we don't want to assume that and it
- isn't very portable anyway; this is. */
-
- memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
- }
+ rt = (rtx) obstack_alloc (rtl_obstack,
+ sizeof (struct rtx_def)
+ + ((n - 1) * sizeof (rtunion)));
+
+ /* We want to clear everything up to the FLD array. Normally, this
+ is one int, but we don't want to assume that and it isn't very
+ portable anyway; this is. */
+ memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
PUT_CODE (rt, code);
return rt;
}
===================================================================
Index: stmt.c
--- stmt.c 2000/06/06 03:37:50 1.151
+++ stmt.c 2000/06/08 21:56:16
@@ -1011,7 +1011,7 @@ expand_fixup (tree_label, rtl_label, las
{
/* Ok, a fixup is needed. Add a fixup to the list of such. */
struct goto_fixup *fixup
- = (struct goto_fixup *) ggc_alloc_obj (sizeof (struct goto_fixup), 0);
+ = (struct goto_fixup *) ggc_alloc (sizeof (struct goto_fixup));
/* In case an old stack level is restored, make sure that comes
after any pending stack adjust. */
/* ?? If the fixup isn't to come at the present position,
===================================================================
Index: tree.c
--- tree.c 2000/05/31 18:36:05 1.147
+++ tree.c 2000/06/08 21:56:17
@@ -1041,11 +1041,10 @@ make_node (code)
if (ggc_p)
t = ggc_alloc_tree (length);
else
- {
- t = (tree) obstack_alloc (obstack, length);
- memset ((PTR) t, 0, length);
- }
+ t = (tree) obstack_alloc (obstack, length);
+ memset ((PTR) t, 0, length);
+
#ifdef GATHER_STATISTICS
tree_node_counts[(int)kind]++;
tree_node_sizes[(int)kind] += length;
@@ -1604,11 +1603,9 @@ make_tree_vec (len)
if (ggc_p)
t = ggc_alloc_tree (length);
else
- {
- t = (tree) obstack_alloc (obstack, length);
- bzero ((PTR) t, length);
- }
+ t = (tree) obstack_alloc (obstack, length);
+ memset ((PTR) t, 0, length);
TREE_SET_CODE (t, TREE_VEC);
TREE_VEC_LENGTH (t) = len;
TREE_SET_PERMANENT (t);
@@ -2164,11 +2161,10 @@ tree_cons (purpose, value, chain)
if (ggc_p)
node = ggc_alloc_tree (sizeof (struct tree_list));
else
- {
- node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list));
- memset (node, 0, sizeof (struct tree_common));
- }
+ node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list));
+ memset (node, 0, sizeof (struct tree_common));
+
#ifdef GATHER_STATISTICS
tree_node_counts[(int) x_kind]++;
tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
@@ -3384,20 +3380,20 @@ build1 (code, type, node)
if (ggc_p)
t = ggc_alloc_tree (length);
else
- {
- t = (tree) obstack_alloc (obstack, length);
- memset ((PTR) t, 0, length);
- }
+ t = (tree) obstack_alloc (obstack, length);
+ memset ((PTR) t, 0, sizeof (struct tree_common));
+
#ifdef GATHER_STATISTICS
tree_node_counts[(int)kind]++;
tree_node_sizes[(int)kind] += length;
#endif
- TREE_TYPE (t) = type;
TREE_SET_CODE (t, code);
TREE_SET_PERMANENT (t);
+ TREE_TYPE (t) = type;
+ TREE_COMPLEXITY (t) = 0;
TREE_OPERAND (t, 0) = node;
if (node && first_rtl_op (code) != 0 && TREE_SIDE_EFFECTS (node))
TREE_SIDE_EFFECTS (t) = 1;
@@ -5597,7 +5593,7 @@ tree_check_failed (node, code, file, lin
void
tree_class_check_failed (node, cl, file, line, function)
const tree node;
- char cl;
+ int cl;
const char *file;
int line;
const char *function;
===================================================================
Index: tree.h
--- tree.h 2000/06/05 13:16:13 1.177
+++ tree.h 2000/06/08 21:56:19
@@ -309,10 +309,10 @@ struct tree_common
__t; })
extern void tree_check_failed PARAMS ((const tree, enum tree_code,
- const char *, int, const char *))
+ const char *, int, const char *))
ATTRIBUTE_NORETURN;
-extern void tree_class_check_failed PARAMS ((const tree, char,
- const char *, int, const char *))
+extern void tree_class_check_failed PARAMS ((const tree, int,
+ const char *, int, const char *))
ATTRIBUTE_NORETURN;
#else /* not ENABLE_TREE_CHECKING, or not gcc */
===================================================================
Index: varasm.c
--- varasm.c 2000/06/01 16:18:18 1.123
+++ varasm.c 2000/06/08 21:56:20
@@ -2121,7 +2121,7 @@ immed_double_const (i0, i1, mode)
push_obstacks_nochange ();
rtl_in_saveable_obstack ();
- r = gen_rtx_CONST_DOUBLE (mode, NULL_RTX, i0, i1);
+ r = gen_rtx_CONST_DOUBLE (mode, const0_rtx, i0, i1);
pop_obstacks ();
/* Don't touch const_double_chain if not inside any function. */
@@ -2131,11 +2131,6 @@ immed_double_const (i0, i1, mode)
const_double_chain = r;
}
- /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
- Actual use of mem-slot is only through force_const_mem. */
-
- CONST_DOUBLE_MEM (r) = const0_rtx;
-
return r;
}
@@ -2201,12 +2196,15 @@ immed_real_const_1 (d, mode)
PUT_MODE (r, mode);
bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
- /* Don't touch const_double_chain if not inside any function. */
+ /* If we aren't inside a function, don't put r on the
+ const_double_chain. */
if (current_function_decl != 0)
{
CONST_DOUBLE_CHAIN (r) = const_double_chain;
const_double_chain = r;
}
+ else
+ CONST_DOUBLE_CHAIN (r) = NULL_RTX;
/* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
===================================================================
Index: cp/call.c
--- cp/call.c 2000/05/31 19:27:11 1.220
+++ cp/call.c 2000/06/08 21:56:21
@@ -1250,7 +1250,7 @@ add_candidate (candidates, fn, convs, vi
int viable;
{
struct z_candidate *cand
- = (struct z_candidate *) ggc_alloc_obj (sizeof (struct z_candidate), 1);
+ = (struct z_candidate *) ggc_alloc_cleared (sizeof (struct z_candidate));
cand->fn = fn;
cand->convs = convs;
===================================================================
Index: cp/decl.c
--- cp/decl.c 2000/06/07 07:59:00 1.628
+++ cp/decl.c 2000/06/08 21:56:24
@@ -4832,7 +4832,7 @@ lookup_label (id)
We do this before calling make_label_decl so that we get the
IDENTIFIER_LABEL_VALUE before the new label is declared. */
ent = ((struct named_label_list *)
- ggc_alloc_obj (sizeof (struct named_label_list), 1));
+ ggc_alloc_cleared (sizeof (struct named_label_list)));
ent->old_value = IDENTIFIER_LABEL_VALUE (id);
ent->next = named_labels;
named_labels = ent;
===================================================================
Index: cp/lex.c
--- cp/lex.c 2000/06/06 20:11:40 1.201
+++ cp/lex.c 2000/06/08 21:56:25
@@ -4776,7 +4776,7 @@ retrofit_lang_decl (t)
else
size = sizeof (struct lang_decl_flags);
- ld = (struct lang_decl *) ggc_alloc_obj (size, 1);
+ ld = (struct lang_decl *) ggc_alloc_cleared (size);
DECL_LANG_SPECIFIC (t) = ld;
if (current_lang_name == lang_name_cplusplus)