This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[ast-optimizer-branch] simplification fixes for stage1 [patch]
- From: Diego Novillo <dnovillo at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Thu, 2 May 2002 15:42:57 -0400
- Subject: [ast-optimizer-branch] simplification fixes for stage1 [patch]
- Organization: Red Hat Canada
With this patch we get past stage1 for all the front ends. Not
surprisingly, we die shortly after stage2 gets under way.
Committed to the branch.
Diego.
* c-simplify.c (simplify_expr): Constify first argument.
Always work on a copy of the input expression.
Do not simplify COMPOUND_LITERAL_EXPR nor CONSTRUCTOR nodes.
(simplify_array_ref): Constify first argument. Always work on a
copy of the input expression.
(simplify_self_mod_expr): Ditto.
(simplify_component_ref): Ditto.
(simplify_call_expr): Ditto.
(simplify_tree_list): Ditto.
(simplify_cond_expr): Ditto.
When building the THEN_CLAUSE and ELSE_CLAUSE for the new IF_STMT,
create a scope for them and simplify the scope, not the expression.
(simplify_modify_expr): Constify first argument. Always work on a
copy of the input expression.
(simplify_boolean_expr): Ditto.
(simplify_compound_expr): Ditto.
(simplify_save_expr): Ditto.
(simplify_expr_wfl): Ditto.
* tree-cfg.c (tree_find_basic_blocks): Update comments for
-fdump-tree-dot.
(tree_dump_cfg): Ditto.
* tree-dump.c (dump_files): Rename -fdump-tree-graphviz to
-fdump-tree-dot.
* tree-simple.c (is_simple_unary_expr): Do not handle &CONST
expressions.
Handle COMPOUND_LITERAL_EXPR and CONSTRUCTOR nodes.
(is_simple_const): Strip NOPS and handle &CONST expressions.
* tree.h (enum tree_dump_index): Remove references to GraphViz.
* doc/invoke.texi: Update documentation for -fdump-tree-dot.
Index: c-simplify.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/c-simplify.c,v
retrieving revision 1.1.2.14
diff -d -p -d -u -p -r1.1.2.14 c-simplify.c
--- c-simplify.c 1 May 2002 00:30:40 -0000 1.1.2.14
+++ c-simplify.c 2 May 2002 19:09:18 -0000
@@ -60,20 +60,20 @@ static tree simplify_do_stmt PAR
static tree simplify_switch_stmt PARAMS ((tree, tree *));
static tree simplify_decl_stmt PARAMS ((tree, tree *));
static tree simplify_if_stmt PARAMS ((tree, tree *));
-static tree simplify_expr PARAMS ((tree, tree *, tree *,
+static tree simplify_expr PARAMS ((const tree, tree *, tree *,
int (*) PARAMS ((tree)), int));
-static tree simplify_array_ref PARAMS ((tree, tree *, tree *));
-static tree simplify_self_mod_expr PARAMS ((tree, tree *, tree *));
-static tree simplify_component_ref PARAMS ((tree, tree *, tree *));
-static tree simplify_call_expr PARAMS ((tree, tree *, tree *));
-static tree simplify_tree_list PARAMS ((tree, tree *, tree *));
-static tree simplify_cond_expr PARAMS ((tree, tree *, tree *));
-static tree simplify_modify_expr PARAMS ((tree, tree *, tree *));
-static tree simplify_boolean_expr PARAMS ((tree, tree *, tree *));
-static tree simplify_compound_expr PARAMS ((tree, tree *, tree *));
-static tree simplify_save_expr PARAMS ((tree, tree *, tree *,
+static tree simplify_array_ref PARAMS ((const tree, tree *, tree *));
+static tree simplify_self_mod_expr PARAMS ((const tree, tree *, tree *));
+static tree simplify_component_ref PARAMS ((const tree, tree *, tree *));
+static tree simplify_call_expr PARAMS ((const tree, tree *, tree *));
+static tree simplify_tree_list PARAMS ((const tree, tree *, tree *));
+static tree simplify_cond_expr PARAMS ((const tree, tree *, tree *));
+static tree simplify_modify_expr PARAMS ((const tree, tree *, tree *));
+static tree simplify_boolean_expr PARAMS ((const tree, tree *, tree *));
+static tree simplify_compound_expr PARAMS ((const tree, tree *, tree *));
+static tree simplify_save_expr PARAMS ((const tree, tree *, tree *,
int (*) PARAMS ((tree)), int));
-static tree simplify_expr_wfl PARAMS ((tree, tree *, tree *,
+static tree simplify_expr_wfl PARAMS ((const tree, tree *, tree *,
int (*) PARAMS ((tree)), int));
static void make_type_writable PARAMS ((tree));
static tree add_tree PARAMS ((tree, tree *));
@@ -894,8 +894,8 @@ simplify_decl_stmt (t, post_p)
/** {{{ simplify_expr ()
- Simplifies the expression tree rooted at EXPR. Returns the simplified
- version of EXPR.
+ Simplifies the expression tree rooted at EXPR. Returns a simplified
+ copy of EXPR.
PRE_P points to the list where side effects that must happen before
EXPR should be stored.
@@ -925,7 +925,7 @@ simplify_decl_stmt (t, post_p)
static tree
simplify_expr (expr, pre_p, post_p, simple_test_f, needs_lvalue)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
int (*simple_test_f) PARAMS ((tree));
@@ -999,14 +1000,16 @@ simplify_expr (expr, pre_p, post_p, simp
break;
/* Address expressions must not be simplified. If they are, we may
- end up taking the address of a temporary, instead of the address
- of the original object. */
+ end up taking the address of a temporary, instead of the address
+ of the original object. */
case ADDR_EXPR:
- expr_s = expr;
+ expr_s = copy_node (expr);
break;
+ /* va_arg expressions should also be left alone to avoid confusing the
+ vararg code. FIXME: Is this really necessary? */
case VA_ARG_EXPR:
- expr_s = expr;
+ expr_s = copy_node (expr);
break;
case NOP_EXPR:
@@ -1015,7 +1018,7 @@ simplify_expr (expr, pre_p, post_p, simp
case FIX_CEIL_EXPR:
case FIX_FLOOR_EXPR:
case FIX_ROUND_EXPR:
- expr_s = expr;
+ expr_s = copy_node (expr);
TREE_OPERAND (expr_s, 0) = simplify_expr (TREE_OPERAND (expr_s, 0),
pre_p, post_p,
is_simple_varname,
@@ -1023,21 +1026,20 @@ simplify_expr (expr, pre_p, post_p, simp
break;
case INDIRECT_REF:
- expr_s = expr;
+ expr_s = copy_node (expr);
TREE_OPERAND (expr_s, 0) = simplify_expr (TREE_OPERAND (expr_s, 0),
pre_p, post_p, is_simple_id,
needs_lvalue);
break;
case NEGATE_EXPR:
- expr_s = expr;
+ expr_s = copy_node (expr);
TREE_OPERAND (expr_s, 0) = simplify_expr (TREE_OPERAND (expr_s, 0),
pre_p, post_p, is_simple_val,
needs_lvalue);
break;
- /* Constants may not be allowed in certain contexts, we just pass them
- on so that they get assigned to a new temporary. */
+ /* Constants need not be simplified. */
case INTEGER_CST:
case REAL_CST:
case STRING_CST:
@@ -1045,11 +1047,21 @@ simplify_expr (expr, pre_p, post_p, simp
expr_s = expr;
break;
+ /* Do not simplify compound literals. FIXME: Maybe we should? */
+ case COMPOUND_LITERAL_EXPR:
+ expr_s = expr;
+ break;
+
+ /* Do not simplify constructor expressions. FIXME: Maybe we should? */
+ case CONSTRUCTOR:
+ expr_s = expr;
+ break;
+
/* The following are special cases that are not handled by the original
SIMPLE grammar. */
case STMT_EXPR:
- simplify_stmt (STMT_EXPR_STMT (expr));
expr_s = expr;
+ simplify_stmt (STMT_EXPR_STMT (expr));
break;
case SAVE_EXPR:
@@ -1063,7 +1075,7 @@ simplify_expr (expr, pre_p, post_p, simp
break;
case BIT_FIELD_REF:
- expr_s = expr;
+ expr_s = copy_node (expr);
TREE_OPERAND (expr_s, 0) = simplify_expr (TREE_OPERAND (expr_s, 0),
pre_p, post_p, is_simple_id,
needs_lvalue);
@@ -1078,26 +1090,22 @@ simplify_expr (expr, pre_p, post_p, simp
break;
case NON_LVALUE_EXPR:
- expr_s = expr;
+ expr_s = copy_node (expr);
TREE_OPERAND (expr_s, 0) = simplify_expr (TREE_OPERAND (expr_s, 0),
pre_p, post_p, simple_test_f,
0);
break;
- /* If EXPR does not need to be special-cased, handle it according to
+ /* If EXPR_S does not need to be special-cased, handle it according to
its class. */
default:
{
- expr_s = expr;
+ expr_s = copy_node (expr);
if (TREE_CODE_CLASS (TREE_CODE (expr_s)) == '1')
- {
- tree t;
-
- t = simplify_expr (TREE_OPERAND (expr_s, 0), pre_p, post_p,
- is_simple_val, 0);
- TREE_OPERAND (expr_s, 0) = t;
- }
+ TREE_OPERAND (expr_s, 0) = simplify_expr (TREE_OPERAND (expr_s, 0),
+ pre_p, post_p,
+ is_simple_val, 0);
else if (TREE_CODE_CLASS (TREE_CODE (expr_s)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (expr_s)) == '<'
|| TREE_CODE (expr_s) == TRUTH_AND_EXPR
@@ -1118,7 +1126,7 @@ simplify_expr (expr, pre_p, post_p, simp
else
{
fprintf (stderr, "unhandled expression in simplify_expr ():\n");
- debug_tree (expr_s);
+ debug_tree (expr);
abort ();
}
}
@@ -1211,22 +1219,23 @@ simplify_expr (expr, pre_p, post_p, simp
static tree
simplify_array_ref (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
- tree base;
+ tree expr_s, base;
varray_type dim_stack;
if (TREE_CODE (expr) != ARRAY_REF)
abort ();
+ expr_s = copy_node (expr);
VARRAY_GENERIC_PTR_INIT (dim_stack, 10, "dim_stack");
/* Create a stack with all the dimensions of the array so that they can
be simplified from left to right. */
- base = expr;
- VARRAY_PUSH_GENERIC_PTR (dim_stack, (PTR)&(TREE_OPERAND (expr, 1)));
+ base = expr_s;
+ VARRAY_PUSH_GENERIC_PTR (dim_stack, (PTR)&(TREE_OPERAND (expr_s, 1)));
while (TREE_CODE (TREE_OPERAND (base, 0)) == ARRAY_REF)
{
base = TREE_OPERAND (base, 0);
@@ -1250,7 +1259,7 @@ simplify_array_ref (expr, pre_p, post_p)
VARRAY_FREE (dim_stack);
/* Return the simplified array expression. */
- return expr;
+ return expr_s;
}
/* }}} */
@@ -1267,7 +1276,7 @@ simplify_array_ref (expr, pre_p, post_p)
static tree
simplify_self_mod_expr (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
@@ -1335,11 +1344,11 @@ simplify_self_mod_expr (expr, pre_p, pos
static tree
simplify_component_ref (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
- tree lhs, rhs;
+ tree expr_s, lhs, rhs;
if (TREE_CODE (expr) != COMPONENT_REF)
abort ();
@@ -1351,10 +1360,11 @@ simplify_component_ref (expr, pre_p, pos
rhs = simplify_expr (TREE_OPERAND (expr, 1), pre_p, post_p, is_simple_id, 0);
- TREE_OPERAND (expr, 0) = lhs;
- TREE_OPERAND (expr, 1) = rhs;
+ expr_s = copy_node (expr);
+ TREE_OPERAND (expr_s, 0) = lhs;
+ TREE_OPERAND (expr_s, 1) = rhs;
- return expr;
+ return expr_s;
}
/* }}} */
@@ -1378,11 +1388,11 @@ simplify_component_ref (expr, pre_p, pos
static tree
simplify_call_expr (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
- tree id, arglist;
+ tree expr_s, id, arglist;
if (TREE_CODE (expr) != CALL_EXPR)
abort ();
@@ -1400,11 +1410,12 @@ simplify_call_expr (expr, pre_p, post_p)
arglist = simplify_expr (TREE_OPERAND (expr, 1), pre_p, post_p,
is_simple_arglist, 0);
- TREE_OPERAND (expr, 0) = id;
- if (TREE_OPERAND (expr, 1))
- TREE_OPERAND (expr, 1) = arglist;
+ expr_s = copy_node (expr);
+ TREE_OPERAND (expr_s, 0) = id;
+ if (TREE_OPERAND (expr_s, 1))
+ TREE_OPERAND (expr_s, 1) = arglist;
- return expr;
+ return expr_s;
}
/* }}} */
@@ -1425,16 +1436,17 @@ simplify_call_expr (expr, pre_p, post_p)
static tree
simplify_tree_list (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
- tree op;
+ tree expr_s, op;
if (TREE_CODE (expr) != TREE_LIST)
abort ();
- for (op = expr; op; op = TREE_CHAIN (op))
+ expr_s = copy_list (expr);
+ for (op = expr_s; op; op = TREE_CHAIN (op))
{
tree arg;
@@ -1442,7 +1454,7 @@ simplify_tree_list (expr, pre_p, post_p)
TREE_VALUE (op) = arg;
}
- return expr;
+ return expr_s;
}
/* }}} */
@@ -1467,11 +1479,11 @@ simplify_tree_list (expr, pre_p, post_p)
static tree
simplify_cond_expr (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
- tree t_then, t_else, tmp, pred, tval, fval, new_if, expr_type;
+ tree t_then, t_else, tmp, pr, tval, fval, new_if, expr_type;
expr_type = TREE_TYPE (expr);
@@ -1480,29 +1492,28 @@ simplify_cond_expr (expr, pre_p, post_p)
else
tmp = void_zero_node;
- pred = simplify_expr (TREE_OPERAND (expr, 0), pre_p, post_p, is_simple_expr,
- 0);
-
- tval = simplify_expr (TREE_OPERAND (expr, 1), pre_p, post_p, is_simple_expr,
- 0);
-
- fval = simplify_expr (TREE_OPERAND (expr, 2), pre_p, post_p, is_simple_expr,
- 0);
+ pr = simplify_expr (TREE_OPERAND (expr, 0), pre_p, post_p, is_simple_expr, 0);
+ tval = TREE_OPERAND (expr, 1);
+ fval = TREE_OPERAND (expr, 2);
- /* Build the THEN_CLAUSE 't1 = a;' or 'a;'. */
+ /* Build and simplify the THEN_CLAUSE 't1 = a;' or 'a;'. */
if (!VOID_TYPE_P (expr_type))
t_then = build_stmt (EXPR_STMT, build_modify_expr (tmp, NOP_EXPR, tval));
else
t_then = build_stmt (EXPR_STMT, tval);
+ tree_build_scope (&t_then);
+ simplify_stmt (t_then);
- /* Build the ELSE_CLAUSE 't1 = b;' or 'b;'. */
+ /* Build and simplify the ELSE_CLAUSE 't1 = b;' or 'b;'. */
if (!VOID_TYPE_P (expr_type))
t_else = build_stmt (EXPR_STMT, build_modify_expr (tmp, NOP_EXPR, fval));
else
t_else = build_stmt (EXPR_STMT, fval);
+ tree_build_scope (&t_else);
+ simplify_stmt (t_else);
/* Build a new IF_STMT, and insert it in the PRE_P chain. */
- new_if = build_stmt (IF_STMT, pred, t_then, t_else);
+ new_if = build_stmt (IF_STMT, pr, t_then, t_else);
add_tree (new_if, pre_p);
return tmp;
@@ -1527,11 +1538,11 @@ simplify_cond_expr (expr, pre_p, post_p)
static tree
simplify_modify_expr (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
- tree lhs, rhs;
+ tree expr_s, lhs, rhs;
if (TREE_CODE (expr) != MODIFY_EXPR
&& TREE_CODE (expr) != INIT_EXPR)
@@ -1539,18 +1550,20 @@ simplify_modify_expr (expr, pre_p, post_
/* Break assignment chains (i.e., a = b = c = ...) into individual
assignment expressions. */
- rhs = TREE_OPERAND (expr, 1);
+ expr_s = copy_node (expr);
+ rhs = TREE_OPERAND (expr_s, 1);
if (TREE_CODE (rhs) == MODIFY_EXPR)
{
rhs = simplify_expr (rhs, pre_p, post_p, is_simple_expr, 0);
add_tree (rhs, pre_p);
- TREE_OPERAND (expr, 1) = TREE_OPERAND (rhs, 0);
+ TREE_OPERAND (expr_s, 1) = TREE_OPERAND (rhs, 0);
}
- lhs = simplify_expr (TREE_OPERAND (expr, 0), pre_p, post_p,
+ lhs = simplify_expr (TREE_OPERAND (expr_s, 0), pre_p, post_p,
is_simple_modify_expr_lhs, 1);
- rhs = simplify_expr (TREE_OPERAND (expr, 1), pre_p, post_p, is_simple_rhs, 0);
+ rhs = simplify_expr (TREE_OPERAND (expr_s, 1), pre_p, post_p, is_simple_rhs,
+ 0);
if (TREE_CODE (rhs) == MODIFY_EXPR)
{
@@ -1558,10 +1571,10 @@ simplify_modify_expr (expr, pre_p, post_
rhs = TREE_OPERAND (rhs, 0);
}
- TREE_OPERAND (expr, 0) = lhs;
- TREE_OPERAND (expr, 1) = rhs;
+ TREE_OPERAND (expr_s, 0) = lhs;
+ TREE_OPERAND (expr_s, 1) = rhs;
- return expr;
+ return expr_s;
}
/* }}} */
@@ -1594,7 +1607,7 @@ simplify_modify_expr (expr, pre_p, post_
static tree
simplify_boolean_expr (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
@@ -1653,7 +1666,7 @@ simplify_boolean_expr (expr, pre_p, post
static tree
simplify_compound_expr (expr, pre_p, post_p)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
{
@@ -1752,7 +1765,7 @@ simplify_compound_expr (expr, pre_p, pos
static tree
simplify_save_expr (expr, pre_p, post_p, simple_test_f, needs_lvalue)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
int (*simple_test_f) PARAMS ((tree));
@@ -1809,7 +1822,7 @@ simplify_save_expr (expr, pre_p, post_p,
static tree
simplify_expr_wfl (expr, pre_p, post_p, simple_test_f, needs_lvalue)
- tree expr;
+ const tree expr;
tree *pre_p;
tree *post_p;
int (*simple_test_f) PARAMS ((tree));
Index: tree-cfg.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-cfg.c,v
retrieving revision 1.1.2.13
diff -d -p -d -u -p -r1.1.2.13 tree-cfg.c
--- tree-cfg.c 17 Apr 2002 16:44:55 -0000 1.1.2.13
+++ tree-cfg.c 2 May 2002 19:09:19 -0000
@@ -122,7 +122,7 @@ tree_find_basic_blocks (t)
/* Create the edges of the flowgraph. */
make_edges ();
- /* Write the flowgraph to a GraphViz file. */
+ /* Write the flowgraph to a dot file. */
dump_file = dump_begin (TDI_dot, &dump_flags);
if (dump_file)
{
@@ -2562,8 +2562,7 @@ tree_dump_cfg (file)
/* {{{ tree_cfg2dot()
- Dump the flowgraph to a .dot FILE to be visualized with GraphViz.
- See http://www.graphviz.org/ */
+ Dump the flowgraph to a .dot FILE. */
void
tree_cfg2dot (file)
Index: tree-dump.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-dump.c,v
retrieving revision 1.2.4.6
diff -d -p -d -u -p -r1.2.4.6 tree-dump.c
--- tree-dump.c 2 Apr 2002 15:26:40 -0000 1.2.4.6
+++ tree-dump.c 2 May 2002 19:09:19 -0000
@@ -808,7 +808,7 @@ static struct dump_file_info dump_files[
{".optimized", "dump-tree-optimized", 0, 0},
{".inlined", "dump-tree-inlined", 0, 0},
{".cfg", "dump-tree-cfg", 0, 0},
- {".dot", "dump-tree-graphviz", 0, 0},
+ {".dot", "dump-tree-dot", 0, 0},
{".ssa", "dump-tree-ssa", 0, 0},
{".simple", "dump-tree-simple", 0, 0},
{".xml", "dump-call-graph", 0, 0},
Index: tree-simple.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-simple.c,v
retrieving revision 1.1.2.7
diff -d -p -d -u -p -r1.1.2.7 tree-simple.c
--- tree-simple.c 1 May 2002 00:30:40 -0000 1.1.2.7
+++ tree-simple.c 2 May 2002 19:09:19 -0000
@@ -510,9 +510,6 @@ is_simple_condexpr (t)
: simp_expr
| '*' ID
| '&' varname
- | '&' CONST => Needed for constant strings.
- Not present in the original
- grammar.
| call_expr
| unop val
| '(' cast ')' varname
@@ -543,8 +540,7 @@ is_simple_unary_expr (t)
return 1;
if (TREE_CODE (t) == ADDR_EXPR
- && (is_simple_varname (TREE_OPERAND (t, 0))
- || is_simple_const (TREE_OPERAND (t, 0))))
+ && is_simple_varname (TREE_OPERAND (t, 0)))
return 1;
if (is_simple_call_expr (t))
@@ -575,6 +571,16 @@ is_simple_unary_expr (t)
if (TREE_CODE (t) == VA_ARG_EXPR)
return 1;
+ /* Addition to the original grammar. Allow compound literals.
+ FIXME: Should we deal with these differently? */
+ if (TREE_CODE (t) == COMPOUND_LITERAL_EXPR)
+ return 1;
+
+ /* Addition to the original grammar. Allow constructor expressions.
+ FIXME: Should we deal with these differently? */
+ if (TREE_CODE (t) == CONSTRUCTOR)
+ return 1;
+
return 0;
}
@@ -665,6 +671,12 @@ int
is_simple_const (t)
tree t;
{
+ STRIP_NOPS (t);
+
+ if (TREE_CODE (t) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
+ return 1;
+
return (TREE_CODE (t) == INTEGER_CST
|| TREE_CODE (t) == REAL_CST
|| TREE_CODE (t) == STRING_CST
Index: tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.h,v
retrieving revision 1.257.2.8
diff -d -p -d -u -p -r1.257.2.8 tree.h
--- tree.h 28 Apr 2002 18:48:47 -0000 1.257.2.8
+++ tree.h 2 May 2002 19:09:20 -0000
@@ -3032,7 +3032,7 @@ enum tree_dump_index
TDI_inlined, /* dump each function after inlining
within it. */
TDI_cfg, /* dump the flowgraph for each function. */
- TDI_dot, /* create a GraphViz graph file for each
+ TDI_dot, /* create a dot graph file for each
function's flowgraph. */
TDI_ssa, /* dump SSA information for each function. */
TDI_simple, /* dump each function before and after
Index: doc/invoke.texi
===================================================================
RCS file: /cvs/gcc/gcc/gcc/doc/invoke.texi,v
retrieving revision 1.39.4.12
diff -d -p -d -u -p -r1.39.4.12 invoke.texi
--- doc/invoke.texi 28 Apr 2002 18:50:06 -0000 1.39.4.12
+++ doc/invoke.texi 2 May 2002 19:09:26 -0000
@@ -247,7 +247,7 @@ in the following sections.
-fdump-class-hierarchy@r{[}-@var{n}@r{]} @gol
-fdump-tree-original@r{[}-@var{n}@r{]} -fdump-tree-optimized@r{[}-@var{n}@r{]} @gol
-fdump-tree-inlined@r{[}-@var{n}@r{]} @gol
--fdump-tree-cfg -fdump-tree-graphviz -fdump-tree-ssa@r{[}-@var{n}@r{]} @gol
+-fdump-tree-cfg -fdump-tree-dot -fdump-tree-ssa@r{[}-@var{n}@r{]} @gol
-fdump-tree-simple@r{[}-unparse@r{]} @gol
-fmem-report @gol
-fprofile-arcs -ftest-coverage -ftime-report @gol
@@ -3079,11 +3079,10 @@ Dump after function inlining, to @file{@
Dump the control flow graph of each function to a file. The file name is
made by appending @file{.cfg} to the source file name.
-@item graphviz
-@opindex fdump-tree-graphviz
-Dump a representation of the control flow graph, suitable for viewing with
-GraphViz, to a file. The file name is made by appending @file{.dot} to the
-source file name.
+@item dot
+@opindex fdump-tree-dot
+Dump a dot language representation of the control flow graph to a file. The
+file name is made by appending @file{.dot} to the source file name.
@item ssa
@opindex fdump-tree-ssa