This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[ast-optimizer-branch] unparsing cleanups [patch]
- From: Diego Novillo <dnovillo at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Fri, 25 Jan 2002 17:23:39 -0500
- Subject: [ast-optimizer-branch] unparsing cleanups [patch]
- Organization: Red Hat Canada
This patch:
- Adds a new dump option -fdump-tree-simple to print out each
function before and after simplification. We can request a
normal tree dump or a dump using Sebastian Pop's unparsing
code.
- Unifies the code to unparse common binary and unary expressions
to use brackets based on operator precedence rules.
- Changes the simplification of return expressions to avoid
creating unnecessary temporary variables.
I've also incorporated Sebastian's cleanup patch.
Diego.
2002-01-25 Diego Novillo <dnovillo@redhat.com>
* Makefile.in (c-pretty-print.o): Add dependency on errors.h.
* c-decl.c (c_expand_body): React to -ftree-dump-simple.
* c-pretty-print.c: Fix typo in header comment.
(NYI): Flush output buffer, dump the tree and abort.
(dump_c_node): Add unparsing code for ERROR_MARK, IDENTIFIER_NODE,
ARRAY_TYPE, UNION_TYPE, STRING_CST, CEIL_DIV_EXPR, FLOOR_DIV_EXPR,
ROUND_DIV_EXPR, TRUNC_MOD_EXPR, FLOOR_MOD_EXPR, ROUND_MOD_EXPR,
RDIV_EXPR, EXACT_DIV_EXPR, LROTATE_EXPR, RROTATE_EXPR,
BIT_ANDTC_EXPR, BIT_NOT_EXPR, UNORDERED_EXPR, SAVE_EXPR and
EXPR_WITH_FILE_LOCATION.
Unify unparsing code for common binary and unary expressions.
Handle indirect references like any other unary expression.
(dump_c_scope_vars): Remove unused variable 'context'.
Call dump_c_node to print the type.
(dump_c_indirect_ref): Remove.
(op_prio): New function.
(op_symbol): New function.
* c-simplify.c (simplify_stmt): Do not simplify a return
expression, only its second operand.
Fix capitalization in error message.
(simplify_expr): Add documentation.
Fix capitalization in error message.
* tree-dump.c (dump_files): Add entry for -fdump-tree-simple.
(dump_options): Add entry for -unparse.
* tree.h (TDI_simple): Define.
(TDF_UNPARSE): Define.
* doc/invoke.texi: Document -fdump-tree-simple.
2002-01-23 Sebastian Pop <s.pop@laposte.net>
* c-pretty-print.c : Clean C++ comments.
(debug_output_buffer): Remove declaration and definition.
* diagnostic.h (debug_output_buffer): Add declaration.
* diagnostic.c (debug_output_buffer): Add definition.
Index: Makefile.in
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Makefile.in,v
retrieving revision 1.701.2.11
diff -d -p -d -u -p -r1.701.2.11 Makefile.in
--- Makefile.in 2002/01/21 01:33:01 1.701.2.11
+++ Makefile.in 2002/01/25 21:47:36
@@ -1333,7 +1333,7 @@ tree-optimize.o : tree-optimize.c tree-o
c-simplify.o : c-simplify.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) errors.h \
$(C_TREE_H) $(C_COMMON_H) diagnostic.h
c-pretty-print.o : c-pretty-print.c $(CONFIG_H) $(SYSTEM_H) \
- $(RTL_H) $(TREE_H) $(EXPR_H) $(C_COMMON_H) diagnostic.h
+ $(RTL_H) $(TREE_H) $(EXPR_H) $(C_COMMON_H) errors.h diagnostic.h
stor-layout.o : stor-layout.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) flags.h \
function.h $(EXPR_H) $(RTL_H) toplev.h $(GGC_H) $(TM_P_H)
fold-const.o : fold-const.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) flags.h \
Index: c-decl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-decl.c,v
retrieving revision 1.239.2.6
diff -d -p -d -u -p -r1.239.2.6 c-decl.c
--- c-decl.c 2002/01/21 01:33:02 1.239.2.6
+++ c-decl.c 2002/01/25 21:47:37
@@ -6978,9 +6978,41 @@ c_expand_body (fndecl, nested_p, can_def
/* Invoke the SSA tree optimizer. */
if (flag_tree_ssa)
{
+ FILE *dump_file;
+ int dump_flags;
tree fn = DECL_SAVED_TREE (fndecl);
- simplify_stmt (fn, NULL);
+ /* Debugging dump before simplification. */
+ dump_file = dump_begin (TDI_simple, &dump_flags);
+ if (dump_file)
+ {
+ fprintf (dump_file, "\n%s() (ORIGINAL)\n",
+ IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
+
+ if (dump_flags & TDF_UNPARSE)
+ print_c_tree (dump_file, fn);
+ else
+ dump_node (fn, TDF_SLIM | dump_flags, dump_file);
+ }
+
+ /* Simplify the function. */
+ simplify_stmt (fn, NULL_TREE);
+
+ /* Debugging dump after simplification. */
+ if (dump_file)
+ {
+ fprintf (dump_file, "\n%s() (SIMPLIFIED)\n",
+ IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
+
+ if (dump_flags & TDF_UNPARSE)
+ print_c_tree (dump_file, fn);
+ else
+ dump_node (fn, TDF_SLIM | dump_flags, dump_file);
+
+ dump_end (TDI_simple, dump_file);
+ }
+
+ /* Apply the SSA optimizations. */
optimize_tree (fn);
}
Index: c-pretty-print.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/c-pretty-print.c,v
retrieving revision 1.1.2.1
diff -d -p -d -u -p -r1.1.2.1 c-pretty-print.c
--- c-pretty-print.c 2002/01/21 01:33:02 1.1.2.1
+++ c-pretty-print.c 2002/01/25 21:47:37
@@ -1,4 +1,4 @@
-/* Pretty formating of a tree in C syntax.
+/* Pretty formatting of a tree in C syntax.
Copyright (C) 2001 Free Software Foundation, Inc.
Contributed by Sebastian Pop <s.pop@laposte.net>
@@ -21,6 +21,7 @@ Software Foundation, 59 Temple Place - S
#include "config.h"
#include "system.h"
+#include "errors.h"
#include "tree.h"
#include "c-tree.h"
#include "c-common.h"
@@ -30,19 +31,8 @@ Software Foundation, 59 Temple Place - S
static void dump_c_scope_vars PARAMS ((output_buffer*, tree, HOST_WIDE_INT));
static void dump_c_tree PARAMS ((output_buffer*, tree, HOST_WIDE_INT));
static int dump_c_node PARAMS ((output_buffer*, tree, HOST_WIDE_INT));
-static void dump_c_indirect_ref PARAMS ((output_buffer*, tree, HOST_WIDE_INT));
-
-// To be declared in another .h file ...
-extern void debug_output_buffer PARAMS ((output_buffer*));
-
-
-/* Dump the contents of an output_buffer on stderr. */
-void
-debug_output_buffer (buffer)
- output_buffer *buffer;
-{
- fprintf (stderr, "%s", output_message_text (buffer));
-}
+static int op_prio PARAMS ((tree));
+static const char *op_symbol PARAMS ((tree));
/* Print the tree T in full, on file FILE. */
@@ -133,22 +123,25 @@ dump_c_node (buffer, node, spc)
HOST_WIDE_INT i;
tree type;
tree op0, op1;
- enum tree_code tc0, tc1;
if (node == NULL_TREE)
return spc;
#define INDENT_PRINT_C_NODE(SPACE) for (i = 0; i<SPACE; i++) output_add_space (buffer)
- //#define NIY output_add_string (buffer, "NIY "); break
-#define NIY goto NotImplementedYet
+#define NIY debug_output_buffer (buffer); debug_tree (node); abort ()
+
/* Keep the following switch ordered as in 'tree.def' and 'c-common.def'. */
switch (TREE_CODE (node))
{
case ERROR_MARK:
- NIY;
+ output_add_string (buffer, "<<< error >>>");
+ break;
+
case IDENTIFIER_NODE:
- NIY;
+ output_add_string (buffer, IDENTIFIER_POINTER (node));
+ break;
+
case TREE_LIST:
while (node && node != error_mark_node)
{
@@ -161,11 +154,14 @@ dump_c_node (buffer, node, spc)
}
}
break;
+
case TREE_VEC:
dump_c_node (buffer, BINFO_TYPE (node), spc);
break;
+
case BLOCK:
NIY;
+
case VOID_TYPE:
case INTEGER_TYPE:
case REAL_TYPE:
@@ -174,33 +170,78 @@ dump_c_node (buffer, node, spc)
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
case CHAR_TYPE:
- output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
+ {
+ unsigned int quals = TYPE_QUALS (node);
+
+ if (quals & TYPE_QUAL_CONST)
+ output_add_string (buffer, "const ");
+ else if (quals & TYPE_QUAL_VOLATILE)
+ output_add_string (buffer, "volatile ");
+
+ output_add_string (buffer,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
+ output_add_space (buffer);
+ }
break;
+
case POINTER_TYPE:
dump_c_node (buffer, TREE_TYPE (node), spc);
- output_add_character (buffer, '*');
+ output_add_string (buffer, " *");
break;
+
case OFFSET_TYPE:
NIY;
+
case REFERENCE_TYPE:
NIY;
+
case METHOD_TYPE:
output_add_string (buffer, IDENTIFIER_POINTER
(DECL_NAME (TYPE_NAME (TYPE_METHOD_BASETYPE (node)))));
output_add_string (buffer, "::");
break;
+
case FILE_TYPE:
NIY;
+
case ARRAY_TYPE:
- NIY;
+ {
+ tree tmp;
+
+ /* Print the array type. */
+ dump_c_node (buffer, TREE_TYPE (node), spc);
+
+ /* Print the dimensions. */
+ tmp = node;
+ while (tmp && TREE_CODE (tmp) == ARRAY_TYPE)
+ {
+ output_add_character (buffer, '[');
+ output_decimal (buffer,
+ TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
+ TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
+ output_add_character (buffer, ']');
+ tmp = TREE_TYPE (tmp);
+ }
+ break;
+ }
+
case SET_TYPE:
NIY;
+
case RECORD_TYPE:
+ case UNION_TYPE:
/* I have to work a little more on this node... */
/* Print the name of the structure. */
if (TYPE_NAME (node))
- output_add_string (buffer, IDENTIFIER_POINTER (TYPE_NAME (node)));
+ {
+ if (TREE_CODE (node) == RECORD_TYPE)
+ output_add_string (buffer, "struct ");
+ else if (TREE_CODE (node) == UNION_TYPE)
+ output_add_string (buffer, "union ");
+
+ dump_c_node (buffer, TYPE_NAME (node), spc);
+ }
output_add_newline (buffer);
INDENT_PRINT_C_NODE (spc);
output_add_character (buffer, '{');
@@ -236,24 +277,26 @@ dump_c_node (buffer, node, spc)
INDENT_PRINT_C_NODE (spc);
output_add_character (buffer, '}');
break;
- case UNION_TYPE:
- NIY;
+
case QUAL_UNION_TYPE:
NIY;
+
case FUNCTION_TYPE:
break;
+
case LANG_TYPE:
NIY;
+
case INTEGER_CST:
if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
/* In the case of a pointer, divise by the size of the pointed type. */
output_decimal (buffer,
TREE_INT_CST_LOW (node) /
- TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE
- (TREE_TYPE (node)))) );
+ TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node))));
else
output_decimal (buffer, TREE_INT_CST_LOW (node));
break;
+
case REAL_CST:
/* Code copied from print_node. */
{
@@ -284,12 +327,17 @@ dump_c_node (buffer, node, spc)
#endif
break;
}
+
case COMPLEX_CST:
NIY;
+
case STRING_CST:
- NIY;
- case FUNCTION_DECL:
+ output_add_string (buffer, "\"");
+ output_add_string (buffer, TREE_STRING_POINTER (node));
+ output_add_string (buffer, "\"");
+ break;
+ case FUNCTION_DECL:
if (!DECL_INITIAL (node))
{
/* Print the prototype of the function. */
@@ -336,8 +384,8 @@ dump_c_node (buffer, node, spc)
dump_c_node (buffer, DECL_RESULT (node), spc);
output_add_space (buffer);
- /* In C++ TREE_TYPE (node) could be a METHOD_TYPE containing the namespace.
- Otherwise it's a FUNCTION_TYPE. */
+ /* In C++ TREE_TYPE (node) could be a METHOD_TYPE containing the
+ namespace. Otherwise it's a FUNCTION_TYPE. */
dump_c_node (buffer, TREE_TYPE (node), spc);
/* Print the name of the function. */
@@ -353,9 +401,10 @@ dump_c_node (buffer, node, spc)
{
/* In C++ the first argument of a method is the pointer (*this).
This condition avoids to print it. */
- if (TREE_TYPE (node) == NULL_TREE ||
- TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE ||
- TREE_TYPE (TREE_TYPE (tmp)) != TYPE_METHOD_BASETYPE (TREE_TYPE (node)))
+ if (TREE_TYPE (node) == NULL_TREE
+ || TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
+ || TREE_TYPE (TREE_TYPE (tmp)) !=
+ TYPE_METHOD_BASETYPE (TREE_TYPE (node)))
{
/* Print the type. */
dump_c_node (buffer, TREE_TYPE (tmp), spc);
@@ -381,14 +430,17 @@ dump_c_node (buffer, node, spc)
}
output_add_newline (buffer);
break;
+
case LABEL_DECL:
if (DECL_NAME (node))
output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (node)));
break;
+
case CONST_DECL:
if (DECL_NAME (node))
output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (node)));
break;
+
case TYPE_DECL:
if (strcmp (DECL_SOURCE_FILE (node), "<built-in>") == 0)
{
@@ -419,65 +471,63 @@ dump_c_node (buffer, node, spc)
}
}
break;
+
case VAR_DECL:
- if (DECL_NAME (node))
- output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (node)));
- break;
case PARM_DECL:
if (DECL_NAME (node))
output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (node)));
break;
+
case RESULT_DECL:
dump_c_node (buffer, TREE_TYPE (node), spc);
break;
+
case FIELD_DECL:
if (DECL_NAME (node))
output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (node)));
break;
+
case NAMESPACE_DECL:
if (DECL_NAME (node))
output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (node)));
break;
+
case COMPONENT_REF:
dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
output_add_character (buffer, '.');
dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
break;
+
case BIT_FIELD_REF:
NIY;
- case INDIRECT_REF:
- dump_c_indirect_ref (buffer, node, TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (node))));
- break;
+
case BUFFER_REF:
NIY;
+
case ARRAY_REF:
op0 = TREE_OPERAND (node, 0);
- if (TREE_CODE (op0) == ARRAY_REF)
- {
- dump_c_node (buffer, op0, spc);
- output_add_character (buffer, '[');
- }
- else
- {
- output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (op0)));
- output_add_character (buffer, '[');
- }
+ dump_c_node (buffer, op0, spc);
+ output_add_character (buffer, '[');
dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
output_add_character (buffer, ']');
break;
+
case ARRAY_RANGE_REF:
NIY;
+
case CONSTRUCTOR:
output_add_character (buffer, '{');
dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
output_add_character (buffer, '}');
break;
+
case COMPOUND_EXPR:
dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
output_add_character (buffer, ',');
output_add_space (buffer);
dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
break;
+
case MODIFY_EXPR:
dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
output_add_space (buffer);
@@ -485,10 +535,13 @@ dump_c_node (buffer, node, spc)
output_add_space (buffer);
dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
break;
+
case INIT_EXPR:
NIY;
+
case TARGET_EXPR:
NIY;
+
case COND_EXPR:
dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
output_add_space (buffer);
@@ -500,335 +553,229 @@ dump_c_node (buffer, node, spc)
output_add_space (buffer);
dump_c_node (buffer, TREE_OPERAND (node, 2), spc);
break;
+
case BIND_EXPR:
NIY;
+
case CALL_EXPR:
- output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (TREE_OPERAND (node, 0), 0))));
+ output_add_string (buffer,
+ IDENTIFIER_POINTER (DECL_NAME
+ (TREE_OPERAND (TREE_OPERAND (node, 0), 0))));
output_add_character (buffer, '(');
op1 = TREE_OPERAND (node, 1);
if (op1)
dump_c_node (buffer, op1, spc);
output_add_character (buffer, ')');
break;
+
case METHOD_CALL_EXPR:
NIY;
+
case WITH_CLEANUP_EXPR:
NIY;
+
case CLEANUP_POINT_EXPR:
NIY;
+
case PLACEHOLDER_EXPR:
NIY;
+
case WITH_RECORD_EXPR:
NIY;
+
+ /* Binary arithmetic and logic expressions. */
+ case MULT_EXPR:
case PLUS_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_space (buffer);
- output_add_character (buffer, '+');
- output_add_space (buffer);
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case MINUS_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_space (buffer);
- output_add_character (buffer, '-');
- output_add_space (buffer);
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
- case MULT_EXPR:
- op0 = TREE_OPERAND (node, 0);
- op1 = TREE_OPERAND (node, 1);
- tc0 = TREE_CODE (op0);
- tc1 = TREE_CODE (op1);
- if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
- dump_c_node (buffer, op0, spc);
- else
- {
- if (tc0 == PLUS_EXPR || tc0 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_node (buffer, op0, spc);
- output_add_character (buffer, ')');
- }
- else
- dump_c_node (buffer, op0, spc);
- output_add_space (buffer);
- output_add_character (buffer, '*');
- output_add_space (buffer);
- if (tc1 == PLUS_EXPR || tc1 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_node (buffer, op1, spc);
- output_add_character (buffer, ')');
- }
- else
- dump_c_node (buffer, op1, spc);
- }
- break;
case TRUNC_DIV_EXPR:
- op0 = TREE_OPERAND (node, 0);
- op1 = TREE_OPERAND (node, 1);
- tc0 = TREE_CODE (op0);
- tc1 = TREE_CODE (op1);
- if (tc0 == PLUS_EXPR || tc0 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_node (buffer, op0, spc);
- output_add_character (buffer, ')');
- }
- else
- dump_c_node (buffer, op0, spc);
- output_add_space (buffer);
- output_add_character (buffer, '/');
- output_add_space (buffer);
- if (tc1 == PLUS_EXPR || tc1 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_node (buffer, op1, spc);
- output_add_character (buffer, ')');
- }
- else
- dump_c_node (buffer, op1, spc);
- break;
case CEIL_DIV_EXPR:
- NIY;
case FLOOR_DIV_EXPR:
- NIY;
case ROUND_DIV_EXPR:
- NIY;
case TRUNC_MOD_EXPR:
- NIY;
case CEIL_MOD_EXPR:
- NIY;
case FLOOR_MOD_EXPR:
- NIY;
case ROUND_MOD_EXPR:
- NIY;
case RDIV_EXPR:
- NIY;
case EXACT_DIV_EXPR:
- NIY;
- case FIX_TRUNC_EXPR:
- case FIX_CEIL_EXPR:
- case FIX_FLOOR_EXPR:
- case FIX_ROUND_EXPR:
- case FLOAT_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- break;
- case NEGATE_EXPR:
- output_add_character (buffer, '-');
- output_add_character (buffer, '(');
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_character (buffer, ')');
- break;
- case MIN_EXPR:
- NIY;
- case MAX_EXPR:
- NIY;
- case ABS_EXPR:
- NIY;
- case FFS_EXPR:
- NIY;
case LSHIFT_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " << ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case RSHIFT_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " >> ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case LROTATE_EXPR:
- NIY;
case RROTATE_EXPR:
- NIY;
case BIT_IOR_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_space (buffer);
- output_add_character (buffer, '|');
- output_add_space (buffer);
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case BIT_XOR_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_space (buffer);
- output_add_character (buffer, '^');
- output_add_space (buffer);
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case BIT_AND_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_space (buffer);
- output_add_character (buffer, '&');
- output_add_space (buffer);
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case BIT_ANDTC_EXPR:
- NIY;
- case BIT_NOT_EXPR:
- NIY;
case TRUTH_ANDIF_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " && ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case TRUTH_ORIF_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " || ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case TRUTH_AND_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " && ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case TRUTH_OR_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " || ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case TRUTH_XOR_EXPR:
- NIY;
- case TRUTH_NOT_EXPR:
- output_add_space (buffer);
- output_add_character (buffer, '!');
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- break;
case LT_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_space (buffer);
- output_add_character (buffer, '<');
- output_add_space (buffer);
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case LE_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " <= ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case GT_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_space (buffer);
- output_add_character (buffer, '>');
- output_add_space (buffer);
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case GE_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " >= ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case EQ_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " == ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
- break;
case NE_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, " != ");
- dump_c_node (buffer, TREE_OPERAND (node, 1), spc);
+ case UNLT_EXPR:
+ case UNLE_EXPR:
+ case UNGT_EXPR:
+ case UNGE_EXPR:
+ case UNEQ_EXPR:
+ {
+ const char *op = op_symbol (node);
+ op0 = TREE_OPERAND (node, 0);
+ op1 = TREE_OPERAND (node, 1);
+
+ /* When the operands are expressions with less priority,
+ keep semantics of the tree representation. */
+ if (op_prio (op0) < op_prio (node))
+ {
+ output_add_character (buffer, '(');
+ dump_c_node (buffer, op0, spc);
+ output_add_character (buffer, ')');
+ }
+ else
+ dump_c_node (buffer, op0, spc);
+
+ output_add_space (buffer);
+ output_add_string (buffer, op);
+ output_add_space (buffer);
+
+ /* When the operands are expressions with less priority,
+ keep semantics of the tree representation. */
+ if (op_prio (op1) < op_prio (node))
+ {
+ output_add_character (buffer, '(');
+ dump_c_node (buffer, op1, spc);
+ output_add_character (buffer, ')');
+ }
+ else
+ dump_c_node (buffer, op1, spc);
+ }
break;
- case UNORDERED_EXPR:
- NIY;
- case ORDERED_EXPR:
+
+ case FIX_TRUNC_EXPR:
+ case FIX_CEIL_EXPR:
+ case FIX_FLOOR_EXPR:
+ case FIX_ROUND_EXPR:
+ case FLOAT_EXPR:
+ dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
+ break;
+
+ /* Unary arithmetic and logic expressions. */
+ case NEGATE_EXPR:
+ case BIT_NOT_EXPR:
+ case TRUTH_NOT_EXPR:
+ case ADDR_EXPR:
+ case REFERENCE_EXPR:
+ case PREDECREMENT_EXPR:
+ case PREINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
+ case POSTINCREMENT_EXPR:
+ case INDIRECT_REF:
+ if (TREE_CODE (node) == ADDR_EXPR
+ && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
+ || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
+ ; /* Do not output '&' for strings and function pointers. */
+ else
+ output_add_string (buffer, op_symbol (node));
+
+ if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
+ {
+ output_add_character (buffer, '(');
+ dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
+ output_add_character (buffer, ')');
+ }
+ else
+ dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
+ break;
+
+ case MIN_EXPR:
NIY;
- case UNLT_EXPR:
+
+ case MAX_EXPR:
NIY;
- case UNLE_EXPR:
+
+ case ABS_EXPR:
NIY;
- case UNGT_EXPR:
+
+ case FFS_EXPR:
NIY;
- case UNGE_EXPR:
+
+ case UNORDERED_EXPR:
NIY;
- case UNEQ_EXPR:
+
+ case ORDERED_EXPR:
NIY;
+
case IN_EXPR:
NIY;
+
case SET_LE_EXPR:
NIY;
+
case CARD_EXPR:
NIY;
+
case RANGE_EXPR:
NIY;
+
case CONVERT_EXPR:
- if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
- dump_c_node (buffer, TREE_OPERAND (TREE_OPERAND (node, 0), 0), spc);
- else
- NIY;
- break;
case NOP_EXPR:
type = TREE_TYPE (node);
if (type == ptr_type_node)
{
- type = TREE_TYPE (node);
- if (type == integer_type_node)
- {
- output_add_string (buffer, "(int*)");
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- }
+ /* Get the pointed-to type. */
+ type = TREE_TYPE (type);
+ output_add_character (buffer, '(');
+ dump_c_node (buffer, type, spc);
+ output_add_string (buffer, " *)");
}
- else
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
+ dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
break;
+
case NON_LVALUE_EXPR:
dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
break;
+
case SAVE_EXPR:
- NIY;
+ dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
+ break;
+
case UNSAVE_EXPR:
- NIY;
- case RTL_EXPR:
- NIY;
- case ADDR_EXPR:
- op0 = TREE_OPERAND (node, 0);
- if (TREE_CODE (TREE_TYPE (op0)) != ARRAY_TYPE)
- output_add_character (buffer, '&');
- output_add_string (buffer, IDENTIFIER_POINTER (DECL_NAME (op0)));
+ dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
break;
- case REFERENCE_EXPR:
+
+ case RTL_EXPR:
NIY;
+
case ENTRY_VALUE_EXPR:
NIY;
+
case COMPLEX_EXPR:
NIY;
+
case CONJ_EXPR:
NIY;
+
case REALPART_EXPR:
NIY;
+
case IMAGPART_EXPR:
NIY;
- case PREDECREMENT_EXPR:
- output_add_string (buffer, " --");
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- break;
- case PREINCREMENT_EXPR:
- output_add_string (buffer, " ++");
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- break;
- case POSTDECREMENT_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, "-- ");
- break;
- case POSTINCREMENT_EXPR:
- dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
- output_add_string (buffer, "++ ");
- break;
+
case VA_ARG_EXPR:
NIY;
+
case TRY_CATCH_EXPR:
NIY;
+
case TRY_FINALLY_EXPR:
NIY;
+
case GOTO_SUBROUTINE_EXPR:
NIY;
+
case LABEL_EXPR:
INDENT_PRINT_C_NODE (spc);
dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
@@ -836,24 +783,30 @@ dump_c_node (buffer, node, spc)
output_add_character (buffer, ';');
output_add_newline (buffer);
break;
+
case GOTO_EXPR:
NIY;
- /*
- case RETURN_EXPR:
- NIY;
- */
+
case EXIT_EXPR:
NIY;
+
case LOOP_EXPR:
NIY;
+
case LABELED_BLOCK_EXPR:
NIY;
+
case EXIT_BLOCK_EXPR:
NIY;
+
case EXPR_WITH_FILE_LOCATION:
- NIY;
+ INDENT_PRINT_C_NODE (spc);
+ dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
+ break;
+
case SWITCH_EXPR:
NIY;
+
case EXC_PTR_EXPR:
NIY;
@@ -861,23 +814,30 @@ dump_c_node (buffer, node, spc)
case SRCLOC:
NIY;
+
case SIZEOF_EXPR:
NIY;
+
case ARROW_EXPR:
NIY;
+
case ALIGNOF_EXPR:
NIY;
+
case EXPR_STMT:
INDENT_PRINT_C_NODE (spc);
dump_c_node (buffer, EXPR_STMT_EXPR (node), spc);
output_add_character (buffer, ';');
output_add_newline (buffer);
break;
+
case COMPOUND_STMT:
dump_c_tree (buffer, COMPOUND_BODY (node), spc);
break;
+
case DECL_STMT:
break;
+
case IF_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "if (");
@@ -893,6 +853,7 @@ dump_c_node (buffer, node, spc)
dump_c_node (buffer, ELSE_CLAUSE (node), spc+2);
}
break;
+
case FOR_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "for (");
@@ -908,6 +869,7 @@ dump_c_node (buffer, node, spc)
output_add_newline (buffer);
dump_c_node (buffer, FOR_BODY (node), spc+2);
break;
+
case WHILE_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "while (");
@@ -916,6 +878,7 @@ dump_c_node (buffer, node, spc)
output_add_newline (buffer);
dump_c_node (buffer, WHILE_BODY (node), spc+2);
break;
+
case DO_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "do");
@@ -928,6 +891,7 @@ dump_c_node (buffer, node, spc)
output_add_character (buffer, ';');
output_add_newline (buffer);
break;
+
case RETURN_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "return ");
@@ -936,16 +900,19 @@ dump_c_node (buffer, node, spc)
output_add_character (buffer, ';');
output_add_newline (buffer);
break;
+
case BREAK_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "break;");
output_add_newline (buffer);
break;
+
case CONTINUE_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "continue;");
output_add_newline (buffer);
break;
+
case SWITCH_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "switch (");
@@ -954,6 +921,7 @@ dump_c_node (buffer, node, spc)
output_add_newline (buffer);
dump_c_node (buffer, SWITCH_BODY (node), spc+2);
break;
+
case GOTO_STMT:
INDENT_PRINT_C_NODE (spc);
output_add_string (buffer, "goto ");
@@ -961,6 +929,7 @@ dump_c_node (buffer, node, spc)
output_add_character (buffer, ';');
output_add_newline (buffer);
break;
+
case LABEL_STMT:
INDENT_PRINT_C_NODE (spc);
dump_c_node (buffer, TREE_OPERAND (node, 0), spc);
@@ -968,8 +937,10 @@ dump_c_node (buffer, node, spc)
output_add_character (buffer, ';');
output_add_newline (buffer);
break;
+
case ASM_STMT:
NIY;
+
case SCOPE_STMT:
if (SCOPE_BEGIN_P (node))
{
@@ -988,6 +959,7 @@ dump_c_node (buffer, node, spc)
output_add_newline (buffer);
}
break;
+
case CASE_LABEL:
INDENT_PRINT_C_NODE (spc-2);
if (CASE_LOW (node) && CASE_HIGH (node))
@@ -1007,6 +979,7 @@ dump_c_node (buffer, node, spc)
output_add_character (buffer, ':');
output_add_newline (buffer);
break;
+
case STMT_EXPR:
output_add_character (buffer, '(');
output_add_newline (buffer);
@@ -1017,9 +990,6 @@ dump_c_node (buffer, node, spc)
default:
NIY;
- NotImplementedYet:;
- output_add_string (buffer, "NIY ");
- break;
}
return spc;
}
@@ -1034,28 +1004,14 @@ dump_c_scope_vars (buffer, scope, spc)
{
HOST_WIDE_INT i;
tree iter = BLOCK_VARS (SCOPE_STMT_BLOCK (scope));
- tree context = NULL_TREE; //BLOCK_SUPERCONTEXT (BLOCK_SUPERCONTEXT (TREE_OPERAND (scope, 0)));
/* Walk through the BLOCK_VARS and print declarations. */
while (iter)
{
INDENT_PRINT_C_NODE (spc);
- /* Is the type declaration local? The expansion of a RECORD_TYPE can be
- handled by looking at the context. */
- if (DECL_CONTEXT (iter) != context)
- {
- /* The declaration of the type is not in the current context. Don't
- expand the declaration in this case : print just the name of the
- type. */
- output_add_string (buffer, IDENTIFIER_POINTER
- (TYPE_NAME (TREE_TYPE (iter))));
- }
- else
- {
- /* Print the entire type declaration. */
- dump_c_node (buffer, TREE_TYPE (iter), spc);
- }
+ if (DECL_REGISTER (iter))
+ output_add_string (buffer, "register ");
/* Print the type and name. */
switch (TREE_CODE (TREE_TYPE (iter)))
@@ -1087,6 +1043,7 @@ dump_c_scope_vars (buffer, scope, spc)
}
break;
}
+
default:
/* Print the entire type declaration. */
dump_c_node (buffer, TREE_TYPE (iter), spc);
@@ -1106,6 +1063,7 @@ dump_c_scope_vars (buffer, scope, spc)
output_add_space (buffer);
dump_c_node (buffer, DECL_INITIAL (iter), spc);
}
+
output_add_character (buffer, ';');
output_add_newline (buffer);
iter = TREE_CHAIN (iter);
@@ -1113,139 +1071,251 @@ dump_c_scope_vars (buffer, scope, spc)
}
-/* Dump the sub-nodes of an INDIRECT_REF. All integers are divided by the size
- SIZE of the type of INDIRECT_REF. */
+/* Return the priority of the operator OP.
-static void
-dump_c_indirect_ref (buffer, node, size)
- output_buffer *buffer;
- tree node;
- HOST_WIDE_INT size;
+ From lowest to highest precedence with either left-to-right (L-R)
+ or right-to-left (R-L) associativity]:
+
+ 1 [L-R] ,
+ 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>=
+ 3 [R-L] ?:
+ 4 [L-R] ||
+ 5 [L-R] &&
+ 6 [L-R] |
+ 7 [L-R] ^
+ 8 [L-R] &
+ 9 [L-R] == !=
+ 10 [L-R] < <= > >=
+ 11 [L-R] << >>
+ 12 [L-R] + -
+ 13 [L-R] * / %
+ 14 [R-L] ! ~ ++ -- + - * & (type) sizeof
+ 15 [L-R] fn() [] -> .
+
+ unary +, - and * have higher precedence than the corresponding binary
+ operators. */
+
+static int
+op_prio (op)
+ tree op;
{
- tree op0, op1;
- enum tree_code tc0, tc1;
- switch (TREE_CODE (node))
+ if (op == NULL)
+ abort ();
+
+ switch (TREE_CODE (op))
{
- case INDIRECT_REF:
- output_add_character (buffer, '*');
- output_add_character (buffer, '(');
- dump_c_indirect_ref (buffer, TREE_OPERAND (node, 0), TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (node))));
- output_add_character (buffer, ')');
- break;
- case CONVERT_EXPR:
- case NOP_EXPR:
- dump_c_indirect_ref (buffer, TREE_OPERAND (node, 0), size);
- break;
- case PLUS_EXPR:
- op0 = TREE_OPERAND (node, 0);
- op1 = TREE_OPERAND (node, 1);
- if (TREE_CODE (op0) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op0) / size);
- else
- dump_c_indirect_ref (buffer, op0, size);
- output_add_space (buffer);
- output_add_character (buffer, '+');
- output_add_space (buffer);
- if (TREE_CODE (op1) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op1) / size);
- else
- dump_c_indirect_ref (buffer, op1, size);
- break;
- case MINUS_EXPR:
- op0 = TREE_OPERAND (node, 0);
- op1 = TREE_OPERAND (node, 1);
- if (TREE_CODE (op0) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op0) / size);
- else
- dump_c_indirect_ref (buffer, op0, size);
- output_add_space (buffer);
- output_add_character (buffer, '-');
- output_add_space (buffer);
- if (TREE_CODE (op1) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op1) / size);
- else
- dump_c_indirect_ref (buffer, op1, size);
- break;
- case MULT_EXPR:
- op0 = TREE_OPERAND (node, 0);
- op1 = TREE_OPERAND (node, 1);
- tc0 = TREE_CODE (op0);
- tc1 = TREE_CODE (op1);
- if (TREE_CODE (op0) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op0) / size);
- else
- {
- if (tc0 == PLUS_EXPR || tc0 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_indirect_ref (buffer, op0, size);
- output_add_character (buffer, ')');
- }
- else
- dump_c_indirect_ref (buffer, op0, size);
- }
- output_add_space (buffer);
- output_add_character (buffer, '*');
- output_add_space (buffer);
- if (TREE_CODE (op1) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op1) / size);
- else
- {
- if (tc1 == PLUS_EXPR || tc1 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_indirect_ref (buffer, op1, size);
- output_add_character (buffer, ')');
- }
- else
- dump_c_indirect_ref (buffer, op1, size);
- }
- break;
- case TRUNC_DIV_EXPR:
- op0 = TREE_OPERAND (node, 0);
- op1 = TREE_OPERAND (node, 1);
- tc0 = TREE_CODE (op0);
- tc1 = TREE_CODE (op1);
- if (TREE_CODE (op0) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op0) / size);
- else
- {
- if (tc0 == PLUS_EXPR || tc0 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_indirect_ref (buffer, op0, size);
- output_add_character (buffer, ')');
- }
- else
- dump_c_indirect_ref (buffer, op0, size);
- }
- output_add_space (buffer);
- output_add_character (buffer, '*');
- output_add_space (buffer);
- if (TREE_CODE (op1) == INTEGER_CST)
- output_decimal (buffer, TREE_INT_CST_LOW (op1) / size);
- else
+ case TREE_LIST:
+ return 1;
+
+ case MODIFY_EXPR:
+ return 2;
+
+ case COND_EXPR:
+ return 3;
+
+ case TRUTH_OR_EXPR:
+ case TRUTH_ORIF_EXPR:
+ return 4;
+
+ case TRUTH_AND_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ return 5;
+
+ case BIT_IOR_EXPR:
+ return 6;
+
+ case BIT_XOR_EXPR:
+ return 7;
+
+ case BIT_AND_EXPR:
+ return 8;
+
+ case EQ_EXPR:
+ case NE_EXPR:
+ return 9;
+
+ case LT_EXPR:
+ case LE_EXPR:
+ case GT_EXPR:
+ case GE_EXPR:
+ return 10;
+
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ return 11;
+
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ return 12;
+
+ case MULT_EXPR:
+ case TRUNC_DIV_EXPR:
+ case CEIL_DIV_EXPR:
+ case FLOOR_DIV_EXPR:
+ case ROUND_DIV_EXPR:
+ case RDIV_EXPR:
+ case EXACT_DIV_EXPR:
+ case TRUNC_MOD_EXPR:
+ case CEIL_MOD_EXPR:
+ case FLOOR_MOD_EXPR:
+ case ROUND_MOD_EXPR:
+ return 13;
+
+ case TRUTH_NOT_EXPR:
+ case BIT_NOT_EXPR:
+ case POSTINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
+ case PREINCREMENT_EXPR:
+ case PREDECREMENT_EXPR:
+ case NEGATE_EXPR:
+ case INDIRECT_REF:
+ case ADDR_EXPR:
+ case FLOAT_EXPR:
+ case NOP_EXPR:
+ case CONVERT_EXPR:
+ case FIX_TRUNC_EXPR:
+ case FIX_CEIL_EXPR:
+ case FIX_FLOOR_EXPR:
+ case FIX_ROUND_EXPR:
+ return 14;
+
+ case CALL_EXPR:
+ case ARRAY_REF:
+ case COMPONENT_REF:
+ return 15;
+
+ /* Special expressions. */
+ case STMT_EXPR:
+ case SAVE_EXPR:
+ return 16;
+
+ default:
+ /* If OP is any type of expression operator, abort because we
+ should know what its relative precedence is. Otherwise, return
+ an arbitrarily high precedence to avoid surrounding single
+ VAR_DECLs in ()s. */
+ if (TREE_CODE_CLASS (TREE_CODE (op)) == '<'
+ || TREE_CODE_CLASS (TREE_CODE (op)) == '1'
+ || TREE_CODE_CLASS (TREE_CODE (op)) == '2'
+ || TREE_CODE_CLASS (TREE_CODE (op)) == 'e')
+ {
+ error ("unhandled expression in op_prio():");
+ debug_tree (op);
+ fputs ("\n", stderr);
+ abort ();
+ }
+ else
+ return 9999;
+ }
+}
+
+
+/* Return the symbol associated with operator OP. */
+
+static const char *
+op_symbol (op)
+ tree op;
+{
+ if (op == NULL)
+ abort ();
+
+ switch (TREE_CODE (op))
+ {
+ case MODIFY_EXPR:
+ return "=";
+
+ case TRUTH_OR_EXPR:
+ case TRUTH_ORIF_EXPR:
+ return "||";
+
+ case TRUTH_AND_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ return "&&";
+
+ case BIT_IOR_EXPR:
+ return "|";
+
+ case BIT_XOR_EXPR:
+ return "^";
+
+ case ADDR_EXPR:
+ case BIT_AND_EXPR:
+ return "&";
+
+ case EQ_EXPR:
+ case UNEQ_EXPR:
+ return "==";
+
+ case NE_EXPR:
+ return "!=";
+
+ case LT_EXPR:
+ case UNLT_EXPR:
+ return "<";
+
+ case LE_EXPR:
+ case UNLE_EXPR:
+ return "<=";
+
+ case GT_EXPR:
+ case UNGT_EXPR:
+ return ">";
+
+ case GE_EXPR:
+ case UNGE_EXPR:
+ return ">=";
+
+ case LSHIFT_EXPR:
+ return "<<";
+
+ case RSHIFT_EXPR:
+ return ">>";
+
+ case PLUS_EXPR:
+ return "+";
+
+ case MINUS_EXPR:
+ return "-";
+
+ case BIT_NOT_EXPR:
+ return "~";
+
+ case MULT_EXPR:
+ case INDIRECT_REF:
+ return "*";
+
+ case TRUNC_DIV_EXPR:
+ case CEIL_DIV_EXPR:
+ case FLOOR_DIV_EXPR:
+ case ROUND_DIV_EXPR:
+ case RDIV_EXPR:
+ case EXACT_DIV_EXPR:
+ return "/";
+
+ case TRUNC_MOD_EXPR:
+ case CEIL_MOD_EXPR:
+ case FLOOR_MOD_EXPR:
+ case ROUND_MOD_EXPR:
+ return "%";
+
+ case PREDECREMENT_EXPR:
+ return " --";
+
+ case PREINCREMENT_EXPR:
+ return " ++";
+
+ case POSTDECREMENT_EXPR:
+ return "-- ";
+
+ case POSTINCREMENT_EXPR:
+ return "++ ";
+
+ default:
{
- if (tc1 == PLUS_EXPR || tc1 == MINUS_EXPR )
- {
- /* When the operands are expressions with less priority,
- keep semantics of the tree representation. */
- output_add_character (buffer, '(');
- dump_c_indirect_ref (buffer, op1, size);
- output_add_character (buffer, ')');
- }
- else
- dump_c_indirect_ref (buffer, op1, size);
+ error ("unhandled expression in op_symbol():");
+ debug_tree (op);
+ fputs ("\n", stderr);
+ abort ();
}
- break;
- default:
- dump_c_node (buffer, node, 0);
- break;
}
}
Index: c-simplify.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/c-simplify.c,v
retrieving revision 1.1.2.1
diff -d -p -d -u -p -r1.1.2.1 c-simplify.c
--- c-simplify.c 2002/01/21 01:33:02 1.1.2.1
+++ c-simplify.c 2002/01/25 21:47:37
@@ -297,9 +297,13 @@ simplify_stmt (stmt, scope)
case RETURN_STMT:
if (RETURN_EXPR (stmt))
- RETURN_EXPR (stmt) = simplify_expr (RETURN_EXPR (stmt),
- scope, &before, &after,
- &new_vars);
+ {
+ tree e = RETURN_EXPR (stmt);
+
+ TREE_OPERAND (e, 1) = simplify_expr (TREE_OPERAND (e, 1),
+ scope, &before, &after,
+ &new_vars);
+ }
break;
case SCOPE_STMT:
@@ -315,7 +319,7 @@ simplify_stmt (stmt, scope)
default:
prep_stmt (stmt);
- error ("Unhandled statement node in simplify_stmt():");
+ error ("unhandled statement node in simplify_stmt():");
fprintf (stderr, "\n");
debug_tree (stmt);
fprintf (stderr, "\n");
@@ -568,8 +572,18 @@ simplify_decl_stmt (t, after_p)
/** {{{ simplify_expr()
Simplifies the expression tree rooted at T.
- SCOPE indicates where new temporary variables should be created. */
+ SCOPE indicates where new temporary variables should be created.
+
+ BEFORE_P points to the list where side effects that must happen before
+ T should be stored.
+
+ AFTER_P points to the list where side effects that must happen after T
+ should be stored.
+
+ NEW_VARS_P points to the list where any temporary VAR_DECLs needed to
+ model T's side effects should be stored. */
+
static tree
simplify_expr (expr, scope, before_p, after_p, new_vars_p)
tree expr;
@@ -781,7 +795,7 @@ simplify_expr (expr, scope, before_p, af
default:
{
- error ("Unhandled expression in simplify_expr():");
+ error ("unhandled expression in simplify_expr():");
debug_tree (expr);
fputs ("\n", stderr);
abort ();
Index: diagnostic.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/diagnostic.c,v
retrieving revision 1.64.2.1
diff -d -p -d -u -p -r1.64.2.1 diagnostic.c
--- diagnostic.c 2001/12/22 19:55:47 1.64.2.1
+++ diagnostic.c 2002/01/25 21:47:37
@@ -1520,3 +1520,12 @@ default_diagnostic_finalizer (buffer, dc
{
output_destroy_prefix (buffer);
}
+
+/* Dump the contents of an output_buffer on stderr. */
+
+void
+debug_output_buffer (buffer)
+ output_buffer *buffer;
+{
+ fprintf (stderr, "%s", output_message_text (buffer));
+}
Index: diagnostic.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/diagnostic.h,v
retrieving revision 1.32.2.1
diff -d -p -d -u -p -r1.32.2.1 diagnostic.h
--- diagnostic.h 2001/12/22 19:55:48 1.32.2.1
+++ diagnostic.h 2002/01/25 21:47:37
@@ diagnostic.h PAR
extern int error_function_changed PARAMS ((void));
extern void record_last_error_function PARAMS ((void));
extern void report_problematic_module PARAMS ((output_buffer *));
+extern void debug_output_buffer PARAMS ((output_buffer *));
/* Called by report_error_function to print out function name.
* Default may be overridden by language front-ends. */
Index: tree-dump.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-dump.c,v
retrieving revision 1.2.4.2
diff -d -p -d -u -p -r1.2.4.2 tree-dump.c
--- tree-dump.c 2001/12/30 03:25:46 1.2.4.2
+++ tree-dump.c 2002/01/25 21:47:38
@@ -803,6 +803,7 @@ static struct dump_file_info dump_files[
{".cfg", "dump-tree-cfg", 0, 0},
{".dot", "dump-tree-graphviz", 0, 0},
{".ssa", "dump-tree-ssa", 0, 0},
+ {".simple", "dump-tree-simple", 0, 0},
};
/* Define a name->number mapping for a dump flag value. */
@@ -818,6 +819,7 @@ static const struct dump_option_value_in
{
{"address", TDF_ADDRESS},
{"slim", TDF_SLIM},
+ {"unparse", TDF_UNPARSE},
{"refs", TDF_REFS},
{"rdefs", TDF_RDEFS},
{"all", ~0},
Index: tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.h,v
retrieving revision 1.257.2.2
diff -d -p -d -u -p -r1.257.2.2 tree.h
--- tree.h 2001/12/22 19:56:51 1.257.2.2
+++ tree.h 2002/01/25 21:47:39
@@ -3111,6 +3111,8 @@ enum tree_dump_index
TDI_dot, /* create a GraphViz graph file for each
function's flowgraph. */
TDI_ssa, /* dump SSA information for each function. */
+ TDI_simple, /* dump each function before and after
+ simplifying it. */
TDI_end
};
@@ -3119,6 +3121,7 @@ enum tree_dump_index
values, extend the DUMP_OPTIONS array in tree-dump.c */
#define TDF_ADDRESS (1 << 0) /* dump node addresses */
#define TDF_SLIM (1 << 1) /* don't go wild following links */
+#define TDF_UNPARSE (1 << 2) /* unparse the function */
#define TDF_REFS (1 << 0) /* dump ssa variable refs */
#define TDF_RDEFS (1 << 1) /* dump reaching definitions */
Index: doc/invoke.texi
===================================================================
RCS file: /cvs/gcc/gcc/gcc/doc/invoke.texi,v
retrieving revision 1.39.4.7
diff -d -p -d -u -p -r1.39.4.7 invoke.texi
--- doc/invoke.texi 2001/12/30 03:26:55 1.39.4.7
+++ doc/invoke.texi 2002/01/25 21:47:43
@@ -246,6 +246,7 @@ in the following sections.
-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-simple@r{[}-unparse@r{]} @gol
-fmem-report -fpretend-float @gol
-fprofile-arcs -ftest-coverage -ftime-report @gol
-g -g@var{level} -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2 @gol
@@ -3019,6 +3020,10 @@ are directly reachable by some other pat
Print the list of references made to each variable in the program.
@item rdefs
Print the list of reaching definitions for each variable used in the program.
+@item unparse
+Print a C representation of the tree. Note that this output may not be
+compilable. It's meant to be an approximation for debugging tree
+transformation passes.
@item all
Turn on all options.
@end table
@@ -3051,6 +3056,10 @@ source file name.
Dump SSA related information to a file. The file name is made by appending
@file{.ssa} to the source file name.
+@item simple
+@opindex fdump-tree-simple
+Dump each function before and after the simplification pass to a file. The
+file name is made by appending @file{.simple} to the source file name.
@end table
@item -fpretend-float