/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
+#include "output.h"
#include "diagnostic.h"
#include "real.h"
#include "hashtab.h"
#include "tree-iterator.h"
#include "tree-chrec.h"
#include "tree-pass.h"
+#include "fixed-value.h"
#include "value-prof.h"
+#include "predict.h"
/* Local functions, macros and variables. */
-static int op_prio (tree);
-static const char *op_symbol (tree);
+static int op_prio (const_tree);
+static const char *op_symbol (const_tree);
static void pretty_print_string (pretty_printer *, const char*);
-static void print_call_name (pretty_printer *, tree);
+static void print_call_name (pretty_printer *, const_tree);
static void newline_and_indent (pretty_printer *, int);
static void maybe_init_pretty_print (FILE *);
static void print_declaration (pretty_printer *, tree, int, int);
-static void print_struct_decl (pretty_printer *, tree, int, int);
-static void do_niy (pretty_printer *, tree);
+static void print_struct_decl (pretty_printer *, const_tree, int, int);
+static void do_niy (pretty_printer *, const_tree);
static void dump_vops (pretty_printer *, tree, int, int);
static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
/* Try to print something for an unknown tree code. */
static void
-do_niy (pretty_printer *buffer, tree node)
+do_niy (pretty_printer *buffer, const_tree node)
{
int i, len;
pp_string (buffer, " >>>\n");
}
+/* Debugging function to print out a generic expression. */
+
void
debug_generic_expr (tree t)
{
fprintf (stderr, "\n");
}
+/* Debugging function to print out a generic statement. */
+
void
debug_generic_stmt (tree t)
{
fprintf (stderr, "\n");
}
+/* Debugging function to print out a chain of trees . */
+
void
debug_tree_chain (tree t)
{
}
/* Print tree T, and its successors, on file FILE. FLAGS specifies details
- to show in the dump. See TDF_* in tree.h. */
+ to show in the dump. See TDF_* in tree-pass.h. */
void
print_generic_stmt (FILE *file, tree t, int flags)
}
/* Print tree T, and its successors, on file FILE. FLAGS specifies details
- to show in the dump. See TDF_* in tree.h. The output is indented by
+ to show in the dump. See TDF_* in tree-pass.h. The output is indented by
INDENT spaces. */
void
}
/* Print a single expression T on file FILE. FLAGS specifies details to show
- in the dump. See TDF_* in tree.h. */
+ in the dump. See TDF_* in tree-pass.h. */
void
print_generic_expr (FILE *file, tree t, int flags)
{
if (TREE_CODE (t) == LABEL_DECL
&& LABEL_DECL_UID (t) != -1)
- pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
- LABEL_DECL_UID (t));
+ pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));
else
{
char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
pp_string (buffer, "default(");
switch (OMP_CLAUSE_DEFAULT_KIND (clause))
{
- case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
- break;
- case OMP_CLAUSE_DEFAULT_SHARED:
- pp_string (buffer, "shared");
- break;
- case OMP_CLAUSE_DEFAULT_NONE:
- pp_string (buffer, "none");
- break;
- case OMP_CLAUSE_DEFAULT_PRIVATE:
- pp_string (buffer, "private");
- break;
- default:
- gcc_unreachable ();
+ case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
+ break;
+ case OMP_CLAUSE_DEFAULT_SHARED:
+ pp_string (buffer, "shared");
+ break;
+ case OMP_CLAUSE_DEFAULT_NONE:
+ pp_string (buffer, "none");
+ break;
+ case OMP_CLAUSE_DEFAULT_PRIVATE:
+ pp_string (buffer, "private");
+ break;
+ case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
+ pp_string (buffer, "firstprivate");
+ break;
+ default:
+ gcc_unreachable ();
}
pp_character (buffer, ')');
break;
case OMP_CLAUSE_SCHEDULE_RUNTIME:
pp_string (buffer, "runtime");
break;
+ case OMP_CLAUSE_SCHEDULE_AUTO:
+ pp_string (buffer, "auto");
+ break;
default:
gcc_unreachable ();
}
pp_character (buffer, ')');
break;
+ case OMP_CLAUSE_UNTIED:
+ pp_string (buffer, "untied");
+ break;
+
+ case OMP_CLAUSE_COLLAPSE:
+ pp_string (buffer, "collapse(");
+ dump_generic_node (buffer,
+ OMP_CLAUSE_COLLAPSE_EXPR (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
+
default:
/* Should never happen. */
dump_generic_node (buffer, clause, spc, flags, false);
}
-/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
- FLAGS specifies details to show in the dump (see TDF_* in tree-pass.h).
- If IS_STMT is true, the object printed is considered to be a statement
- and it is terminated by ';' if appropriate. */
+/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
+ indent. FLAGS specifies details to show in the dump (see TDF_* in
+ tree-pass.h). If IS_STMT is true, the object printed is considered
+ to be a statement and it is terminated by ';' if appropriate. */
int
dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case VOID_TYPE:
case INTEGER_TYPE:
case REAL_TYPE:
+ case FIXED_POINT_TYPE:
case COMPLEX_TYPE:
case VECTOR_TYPE:
case ENUMERAL_TYPE:
if (quals & TYPE_QUAL_CONST)
pp_string (buffer, " const");
- else if (quals & TYPE_QUAL_VOLATILE)
- pp_string (buffer, "volatile");
- else if (quals & TYPE_QUAL_RESTRICT)
+ if (quals & TYPE_QUAL_VOLATILE)
+ pp_string (buffer, " volatile");
+ if (quals & TYPE_QUAL_RESTRICT)
pp_string (buffer, " restrict");
if (TYPE_REF_CAN_ALIAS_ALL (node))
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
- /* Print the name of the structure. */
- if (TREE_CODE (node) == RECORD_TYPE)
- pp_string (buffer, "struct ");
- else if (TREE_CODE (node) == UNION_TYPE)
- pp_string (buffer, "union ");
+ {
+ unsigned int quals = TYPE_QUALS (node);
- if (TYPE_NAME (node))
- dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
- else
- print_struct_decl (buffer, node, spc, flags);
- break;
+ if (quals & TYPE_QUAL_CONST)
+ pp_string (buffer, "const ");
+ if (quals & TYPE_QUAL_VOLATILE)
+ pp_string (buffer, "volatile ");
+
+ /* Print the name of the structure. */
+ if (TREE_CODE (node) == RECORD_TYPE)
+ pp_string (buffer, "struct ");
+ else if (TREE_CODE (node) == UNION_TYPE)
+ pp_string (buffer, "union ");
+
+ if (TYPE_NAME (node))
+ dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
+ else
+ print_struct_decl (buffer, node, spc, flags);
+ break;
+ }
case LANG_TYPE:
NIY;
/* Would "%x%0*x" or "%x%*0x" get zero-padding on all
systems? */
sprintf (pp_buffer (buffer)->digit_buffer,
- HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
+ HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+ (unsigned HOST_WIDE_INT) high, low);
pp_string (buffer, pp_buffer (buffer)->digit_buffer);
}
else
break;
}
+ case FIXED_CST:
+ {
+ char string[100];
+ fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
+ pp_string (buffer, string);
+ break;
+ }
+
case COMPLEX_CST:
pp_string (buffer, "__complex__ (");
dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
if (DECL_NAME (node))
dump_decl_name (buffer, node, flags);
else if (LABEL_DECL_UID (node) != -1)
- pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
- LABEL_DECL_UID (node));
+ pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
else
- pp_printf (buffer, "<D%u>", DECL_UID (node));
+ pp_printf (buffer, "<D.%u>", DECL_UID (node));
break;
case TYPE_DECL:
case SYMBOL_MEMORY_TAG:
case NAME_MEMORY_TAG:
- case STRUCT_FIELD_TAG:
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
pp_character (buffer, ')');
pp_string (buffer, str);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
-
- if (TREE_CODE (op0) != VALUE_HANDLE)
+ op0 = component_ref_field_offset (node);
+ if (op0 && TREE_CODE (op0) != INTEGER_CST)
{
- op0 = component_ref_field_offset (node);
- if (op0 && TREE_CODE (op0) != INTEGER_CST)
- {
- pp_string (buffer, "{off: ");
+ pp_string (buffer, "{off: ");
dump_generic_node (buffer, op0, spc, flags, false);
pp_character (buffer, '}');
- }
}
break;
if (TREE_CODE (node) == GIMPLE_MODIFY_STMT
&& MOVE_NONTEMPORAL (node))
pp_string (buffer, "{nt}");
+ if (TREE_CODE (node) == GIMPLE_MODIFY_STMT)
+ {
+ stmt_ann_t ann;
+ if ((ann = stmt_ann (node))
+ && ann->has_volatile_ops)
+ pp_string (buffer, "{v}");
+ }
pp_space (buffer);
dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
false);
}
}
}
+ if (CALL_EXPR_VA_ARG_PACK (node))
+ {
+ if (call_expr_nargs (node) > 0)
+ {
+ pp_character (buffer, ',');
+ pp_space (buffer);
+ }
+ pp_string (buffer, "__builtin_va_arg_pack ()");
+ }
pp_character (buffer, ')');
op1 = CALL_EXPR_STATIC_CHAIN (node);
NIY;
break;
+ case FIXED_CONVERT_EXPR:
case FIX_TRUNC_EXPR:
case FLOAT_EXPR:
- case CONVERT_EXPR:
- case NOP_EXPR:
+ CASE_CONVERT:
type = TREE_TYPE (node);
op0 = TREE_OPERAND (node, 0);
if (type != TREE_TYPE (op0))
pp_character (buffer, ')');
break;
+ case PAREN_EXPR:
+ pp_string (buffer, "((");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, "))");
+ break;
+
case NON_LVALUE_EXPR:
pp_string (buffer, "NON_LVALUE_EXPR <");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
is_expr = false;
break;
+ case PREDICT_EXPR:
+ pp_string (buffer, "// predicted ");
+ if (PREDICT_EXPR_OUTCOME (node))
+ pp_string (buffer, "likely by ");
+ else
+ pp_string (buffer, "unlikely by ");
+ pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
+ pp_string (buffer, " predictor.");
+ break;
+
case RETURN_EXPR:
pp_string (buffer, "return");
op0 = TREE_OPERAND (node, 0);
pp_string (buffer, ">");
break;
- case VALUE_HANDLE:
- pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
- break;
-
case ASSERT_EXPR:
pp_string (buffer, "ASSERT_EXPR <");
dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
is_expr = false;
break;
+ case OMP_TASK:
+ pp_string (buffer, "#pragma omp task");
+ dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
+ if (OMP_TASK_FN (node))
+ {
+ pp_string (buffer, " [child fn: ");
+ dump_generic_node (buffer, OMP_TASK_FN (node), spc, flags, false);
+
+ pp_string (buffer, " (");
+
+ if (OMP_TASK_DATA_ARG (node))
+ dump_generic_node (buffer, OMP_TASK_DATA_ARG (node), spc, flags,
+ false);
+ else
+ pp_string (buffer, "???");
+
+ pp_character (buffer, ')');
+ if (OMP_TASK_COPYFN (node))
+ {
+ pp_string (buffer, ", copy fn: ");
+ dump_generic_node (buffer, OMP_TASK_COPYFN (node), spc,
+ flags, false);
+ }
+ pp_character (buffer, ']');
+ }
+ goto dump_omp_body;
+
case OMP_FOR:
pp_string (buffer, "#pragma omp for");
dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
if (!(flags & TDF_SLIM))
{
+ int i;
+
if (OMP_FOR_PRE_BODY (node))
{
newline_and_indent (buffer, spc + 2);
dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
spc, flags, false);
}
- newline_and_indent (buffer, spc);
- pp_string (buffer, "for (");
- dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
- pp_string (buffer, "; ");
- dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
- pp_string (buffer, "; ");
- dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
- pp_string (buffer, ")");
+ spc -= 2;
+ for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
+ {
+ spc += 2;
+ newline_and_indent (buffer, spc);
+ pp_string (buffer, "for (");
+ dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
+ spc, flags, false);
+ pp_string (buffer, "; ");
+ dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
+ spc, flags, false);
+ pp_string (buffer, "; ");
+ dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
+ spc, flags, false);
+ pp_string (buffer, ")");
+ }
if (OMP_FOR_BODY (node))
{
newline_and_indent (buffer, spc + 2);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
}
+ spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
if (OMP_FOR_PRE_BODY (node))
{
spc -= 4;
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
break;
+ case OMP_ATOMIC_LOAD:
+ pp_string (buffer, "#pragma omp atomic_load");
+ newline_and_indent (buffer, spc + 2);
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_space (buffer);
+ pp_character (buffer, '=');
+ pp_space (buffer);
+ pp_character (buffer, '*');
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ break;
+
+ case OMP_ATOMIC_STORE:
+ pp_string (buffer, "#pragma omp atomic_store (");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_character (buffer, ')');
+ break;
+
case OMP_SINGLE:
pp_string (buffer, "#pragma omp single");
dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
pp_character (buffer, ')');
}
- /* The initial value of a function serves to determine wether the function
+ /* The initial value of a function serves to determine whether the function
is declared or defined. So the following does not apply to function
nodes. */
if (TREE_CODE (t) != FUNCTION_DECL)
FIXME: Still incomplete. */
static void
-print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
+print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
{
/* Print the name of the structure. */
if (TYPE_NAME (node))
operators. */
static int
-op_prio (tree op)
+op_prio (const_tree op)
{
if (op == NULL)
return 9999;
case INDIRECT_REF:
case ADDR_EXPR:
case FLOAT_EXPR:
- case NOP_EXPR:
- case CONVERT_EXPR:
+ CASE_CONVERT:
case FIX_TRUNC_EXPR:
case TARGET_EXPR:
return 14;
/* Return the symbol associated with operator OP. */
static const char *
-op_symbol (tree op)
+op_symbol (const_tree op)
{
return op_symbol_code (TREE_CODE (op));
}
/* Prints the name of a CALL_EXPR. */
static void
-print_call_name (pretty_printer *buffer, tree node)
+print_call_name (pretty_printer *buffer, const_tree node)
{
tree op0;
pp_string (buffer, "# ");
dump_generic_node (buffer, phi, indent, flags, false);
pp_newline (buffer);
+ if (flags & TDF_VERBOSE)
+ print_node (buffer->buffer->stream, "", phi, indent);
}
}
}
{
INDENT (indent);
- if ((flags & TDF_LINENO)
-#ifdef USE_MAPPED_LOCATION
- && e->goto_locus != UNKNOWN_LOCATION
-#else
- && e->goto_locus
-#endif
- )
+ if ((flags & TDF_LINENO) && e->goto_locus != UNKNOWN_LOCATION)
{
expanded_location goto_xloc;
-#ifdef USE_MAPPED_LOCATION
goto_xloc = expand_location (e->goto_locus);
-#else
- goto_xloc = *e->goto_locus;
-#endif
pp_character (buffer, '[');
if (goto_xloc.file)
{
dump_generic_node (buffer, stmt, curr_indent, flags, true);
pp_newline (buffer);
dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
+ if (flags & TDF_VERBOSE)
+ print_node (buffer->buffer->stream, "", stmt, curr_indent);
}
dump_implicit_edges (buffer, bb, indent, flags);
OSDN Git Service
