/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
#include "tree-iterator.h"
#include "tree-chrec.h"
#include "tree-pass.h"
+#include "value-prof.h"
/* Local functions, macros and variables. */
static int op_prio (tree);
if (EXPR_P (node))
{
- len = TREE_CODE_LENGTH (TREE_CODE (node));
+ len = TREE_OPERAND_LENGTH (node);
for (i = 0; i < len; ++i)
{
newline_and_indent (buffer, 2);
void
debug_generic_expr (tree t)
{
- print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
+ print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
fprintf (stderr, "\n");
}
void
debug_generic_stmt (tree t)
{
- print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
+ print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
fprintf (stderr, "\n");
}
void
debug_tree_chain (tree t)
{
- print_generic_expr (stderr, t, TDF_VOPS|TDF_UID|TDF_CHAIN);
+ while (t)
+ {
+ print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
+ fprintf(stderr, " ");
+ t = TREE_CHAIN (t);
+ }
fprintf (stderr, "\n");
}
{
tree t = node;
- while (t)
+ if (DECL_NAME (t))
+ pp_tree_identifier (buffer, DECL_NAME (t));
+ if ((flags & TDF_UID)
+ || DECL_NAME (t) == NULL_TREE)
{
- if (DECL_NAME (t))
- pp_tree_identifier (buffer, DECL_NAME (t));
-
- if ((flags & TDF_UID)
- || DECL_NAME (t) == NULL_TREE)
- {
- if (TREE_CODE (t) == LABEL_DECL
- && LABEL_DECL_UID (t) != -1)
- pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
- LABEL_DECL_UID (t));
- else
- {
- char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
- pp_printf (buffer, "%c.%u", c, DECL_UID (t));
- }
- }
-
- if (flags & TDF_CHAIN)
+ if (TREE_CODE (t) == LABEL_DECL
+ && LABEL_DECL_UID (t) != -1)
+ pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
+ LABEL_DECL_UID (t));
+ else
{
- t = TREE_CHAIN (t);
- pp_string (buffer, " ");
+ char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
+ pp_printf (buffer, "%c.%u", c, DECL_UID (t));
}
- else
- t = NULL_TREE;
}
}
pp_character (buffer, ']');
}
-/* Dump the list of OpenMP clauses. */
+
+/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
+ dump_generic_node. */
static void
-dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
+dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
{
const char *name;
- if (clause == NULL)
- return;
-
- pp_space (buffer);
- while (1)
+ switch (OMP_CLAUSE_CODE (clause))
{
- switch (TREE_CODE (clause))
- {
- case OMP_CLAUSE_PRIVATE:
- name = "private";
- goto print_remap;
- case OMP_CLAUSE_SHARED:
- name = "shared";
- goto print_remap;
- case OMP_CLAUSE_FIRSTPRIVATE:
- name = "firstprivate";
- goto print_remap;
- case OMP_CLAUSE_LASTPRIVATE:
- name = "lastprivate";
- goto print_remap;
- case OMP_CLAUSE_COPYIN:
- name = "copyin";
- goto print_remap;
- case OMP_CLAUSE_COPYPRIVATE:
- name = "copyprivate";
- goto print_remap;
- print_remap:
- pp_string (buffer, name);
- pp_character (buffer, '(');
- dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
-
- case OMP_CLAUSE_REDUCTION:
- pp_string (buffer, "reduction(");
- pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));
- pp_character (buffer, ':');
- dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_PRIVATE:
+ name = "private";
+ goto print_remap;
+ case OMP_CLAUSE_SHARED:
+ name = "shared";
+ goto print_remap;
+ case OMP_CLAUSE_FIRSTPRIVATE:
+ name = "firstprivate";
+ goto print_remap;
+ case OMP_CLAUSE_LASTPRIVATE:
+ name = "lastprivate";
+ goto print_remap;
+ case OMP_CLAUSE_COPYIN:
+ name = "copyin";
+ goto print_remap;
+ case OMP_CLAUSE_COPYPRIVATE:
+ name = "copyprivate";
+ goto print_remap;
+ print_remap:
+ pp_string (buffer, name);
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_IF:
- pp_string (buffer, "if(");
- dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_REDUCTION:
+ pp_string (buffer, "reduction(");
+ pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));
+ pp_character (buffer, ':');
+ dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_NUM_THREADS:
- pp_string (buffer, "num_threads(");
- dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
- spc, flags, false);
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_IF:
+ pp_string (buffer, "if(");
+ dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_NOWAIT:
- pp_string (buffer, "nowait");
- break;
- case OMP_CLAUSE_ORDERED:
- pp_string (buffer, "ordered");
- break;
+ case OMP_CLAUSE_NUM_THREADS:
+ pp_string (buffer, "num_threads(");
+ dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
- case OMP_CLAUSE_DEFAULT:
- 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 ();
- }
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_NOWAIT:
+ pp_string (buffer, "nowait");
+ break;
+ case OMP_CLAUSE_ORDERED:
+ pp_string (buffer, "ordered");
+ break;
- case OMP_CLAUSE_SCHEDULE:
- pp_string (buffer, "schedule(");
- switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
- {
- case OMP_CLAUSE_SCHEDULE_STATIC:
- pp_string (buffer, "static");
- break;
- case OMP_CLAUSE_SCHEDULE_DYNAMIC:
- pp_string (buffer, "dynamic");
- break;
- case OMP_CLAUSE_SCHEDULE_GUIDED:
- pp_string (buffer, "guided");
- break;
- case OMP_CLAUSE_SCHEDULE_RUNTIME:
- pp_string (buffer, "runtime");
- break;
- default:
- gcc_unreachable ();
- }
- if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
- {
- pp_character (buffer, ',');
- dump_generic_node (buffer,
- OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
- spc, flags, false);
- }
- pp_character (buffer, ')');
- break;
+ case OMP_CLAUSE_DEFAULT:
+ 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 ();
+ }
+ pp_character (buffer, ')');
+ break;
- default:
- /* Should never happen. */
- dump_generic_node (buffer, clause, spc, flags, false);
- break;
+ case OMP_CLAUSE_SCHEDULE:
+ pp_string (buffer, "schedule(");
+ switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
+ {
+ case OMP_CLAUSE_SCHEDULE_STATIC:
+ pp_string (buffer, "static");
+ break;
+ case OMP_CLAUSE_SCHEDULE_DYNAMIC:
+ pp_string (buffer, "dynamic");
+ break;
+ case OMP_CLAUSE_SCHEDULE_GUIDED:
+ pp_string (buffer, "guided");
+ break;
+ case OMP_CLAUSE_SCHEDULE_RUNTIME:
+ pp_string (buffer, "runtime");
+ break;
+ default:
+ gcc_unreachable ();
+ }
+ if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
+ {
+ pp_character (buffer, ',');
+ dump_generic_node (buffer,
+ OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
+ spc, flags, false);
}
+ pp_character (buffer, ')');
+ break;
+
+ default:
+ /* Should never happen. */
+ dump_generic_node (buffer, clause, spc, flags, false);
+ break;
+ }
+}
+
+/* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in
+ dump_generic_node. */
+
+static void
+dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
+{
+ if (clause == NULL)
+ return;
+
+ pp_space (buffer);
+ while (1)
+ {
+ dump_omp_clause (buffer, clause, spc, flags);
clause = OMP_CLAUSE_CHAIN (clause);
if (clause == NULL)
return;
}
}
+
+/* Dump the set of decls SYMS. BUFFER, SPC and FLAGS are as in
+ dump_generic_node. */
+
+static void
+dump_symbols (pretty_printer *buffer, bitmap syms, int flags)
+{
+ unsigned i;
+ bitmap_iterator bi;
+
+ if (syms == NULL)
+ pp_string (buffer, "NIL");
+ else
+ {
+ pp_string (buffer, " { ");
+
+ EXECUTE_IF_SET_IN_BITMAP (syms, 0, i, bi)
+ {
+ tree sym = referenced_var_lookup (i);
+ dump_generic_node (buffer, sym, 0, flags, false);
+ pp_string (buffer, " ");
+ }
+
+ pp_string (buffer, "}");
+ }
+}
+
+
/* 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.h). If
IS_STMT is true, the object printed is considered to be a statement
if (node == NULL_TREE)
return spc;
- is_expr = EXPR_P (node);
+ is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
+ /* We use has_stmt_ann because CALL_EXPR can be both an expression
+ and a statement, and we have no guarantee that it will have a
+ stmt_ann when it is used as an RHS expression. stmt_ann will assert
+ if you call it on something with a non-stmt annotation attached. */
if (TREE_CODE (node) != ERROR_MARK
&& is_gimple_stmt (node)
- && (flags & TDF_VOPS)
- && stmt_ann (node)
+ && (flags & (TDF_VOPS|TDF_MEMSYMS))
+ && has_stmt_ann (node)
&& TREE_CODE (node) != PHI_NODE)
dump_vops (buffer, node, spc, flags);
case VECTOR_TYPE:
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
- case CHAR_TYPE:
{
unsigned int quals = TYPE_QUALS (node);
enum tree_code_class class;
else if (! host_integerp (node, 0))
{
tree val = node;
+ unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
+ HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
if (tree_int_cst_sgn (val) < 0)
{
pp_character (buffer, '-');
- val = build_int_cst_wide (NULL_TREE,
- -TREE_INT_CST_LOW (val),
- ~TREE_INT_CST_HIGH (val)
- + !TREE_INT_CST_LOW (val));
+ high = ~high + !low;
+ low = -low;
}
/* Would "%x%0*x" or "%x%*0x" get zero-padding on all
systems? */
- {
- static char format[10]; /* "%x%09999x\0" */
- if (!format[0])
- sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
- sprintf (pp_buffer (buffer)->digit_buffer, format,
- TREE_INT_CST_HIGH (val),
- TREE_INT_CST_LOW (val));
- pp_string (buffer, pp_buffer (buffer)->digit_buffer);
- }
+ sprintf (pp_buffer (buffer)->digit_buffer,
+ HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
+ pp_string (buffer, pp_buffer (buffer)->digit_buffer);
}
else
pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
d = TREE_REAL_CST (node);
if (REAL_VALUE_ISINF (d))
- pp_string (buffer, " Inf");
+ pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
else if (REAL_VALUE_ISNAN (d))
pp_string (buffer, " Nan");
else
}
break;
- case TYPE_MEMORY_TAG:
+ case SYMBOL_MEMORY_TAG:
case NAME_MEMORY_TAG:
case STRUCT_FIELD_TAG:
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case NAMESPACE_DECL:
+ case MEMORY_PARTITION_TAG:
dump_decl_name (buffer, node, flags);
break;
break;
case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
case INIT_EXPR:
- dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
+ false);
pp_space (buffer);
pp_character (buffer, '=');
pp_space (buffer);
- dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
+ false);
break;
case TARGET_EXPR:
|| TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
{
pp_space (buffer);
- dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
- pp_string (buffer, " else ");
- dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
+ dump_generic_node (buffer, COND_EXPR_THEN (node),
+ 0, flags, true);
+ if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
+ {
+ pp_string (buffer, " else ");
+ dump_generic_node (buffer, COND_EXPR_ELSE (node),
+ 0, flags, true);
+ }
}
else if (!(flags & TDF_SLIM))
{
}
/* Output COND_EXPR_ELSE. */
- if (COND_EXPR_ELSE (node))
+ if (COND_EXPR_ELSE (node)
+ && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
{
newline_and_indent (buffer, spc);
pp_string (buffer, "else");
/* Print parameters. */
pp_space (buffer);
pp_character (buffer, '(');
- op1 = TREE_OPERAND (node, 1);
- if (op1)
- dump_generic_node (buffer, op1, spc, flags, false);
+ {
+ tree arg;
+ call_expr_arg_iterator iter;
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
+ {
+ dump_generic_node (buffer, arg, spc, flags, false);
+ if (more_call_expr_args_p (&iter))
+ {
+ pp_character (buffer, ',');
+ pp_space (buffer);
+ }
+ }
+ }
pp_character (buffer, ')');
- op1 = TREE_OPERAND (node, 2);
+ op1 = CALL_EXPR_STATIC_CHAIN (node);
if (op1)
{
pp_string (buffer, " [static-chain: ");
break;
/* Binary arithmetic and logic expressions. */
+ case WIDEN_SUM_EXPR:
+ case WIDEN_MULT_EXPR:
case MULT_EXPR:
case PLUS_EXPR:
case MINUS_EXPR:
/* When the operands are expressions with less priority,
keep semantics of the tree representation. */
- if (op_prio (op0) < op_prio (node))
+ if (op_prio (op0) <= op_prio (node))
{
pp_character (buffer, '(');
dump_generic_node (buffer, op0, spc, flags, false);
/* When the operands are expressions with less priority,
keep semantics of the tree representation. */
- if (op_prio (op1) < op_prio (node))
+ if (op_prio (op1) <= op_prio (node))
{
pp_character (buffer, '(');
dump_generic_node (buffer, op1, spc, flags, false);
break;
case FIX_TRUNC_EXPR:
- case FIX_CEIL_EXPR:
- case FIX_FLOOR_EXPR:
- case FIX_ROUND_EXPR:
case FLOAT_EXPR:
case CONVERT_EXPR:
case NOP_EXPR:
if (op0)
{
pp_space (buffer);
- if (TREE_CODE (op0) == MODIFY_EXPR)
- dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
+ if (TREE_CODE (op0) == MODIFY_EXPR
+ || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
+ dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
+ spc, flags, false);
else
dump_generic_node (buffer, op0, spc, flags, false);
}
break;
case RESX_EXPR:
- pp_string (buffer, "resx");
- /* ??? Any sensible way to present the eh region? */
+ pp_string (buffer, "resx ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
break;
case ASM_EXPR:
if (i < PHI_NUM_ARGS (node) - 1)
pp_string (buffer, ", ");
}
- pp_string (buffer, ">;");
+ pp_string (buffer, ">");
+
+ if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
+ dump_symbols (buffer, STORED_SYMS (node), flags);
}
break;
pp_decimal_int (buffer, SSA_NAME_VERSION (node));
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
pp_string (buffer, "(ab)");
+ else if (SSA_NAME_IS_DEFAULT_DEF (node))
+ pp_string (buffer, "(D)");
break;
case WITH_SIZE_EXPR:
pp_string (buffer, " > ");
break;
+ case DOT_PROD_EXPR:
+ pp_string (buffer, " DOT_PROD_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
case OMP_PARALLEL:
pp_string (buffer, "#pragma omp parallel");
dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
+ if (OMP_PARALLEL_FN (node))
+ {
+ pp_string (buffer, " [child fn: ");
+ dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
+
+ pp_string (buffer, " (");
+
+ if (OMP_PARALLEL_DATA_ARG (node))
+ dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
+ false);
+ else
+ pp_string (buffer, "???");
+
+ pp_string (buffer, ")]");
+ }
dump_omp_body:
if (!(flags & TDF_SLIM) && OMP_BODY (node))
dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
goto dump_omp_body;
+ case OMP_RETURN:
+ pp_string (buffer, "OMP_RETURN");
+ if (OMP_RETURN_NOWAIT (node))
+ pp_string (buffer, " [nowait]");
+ is_expr = false;
+ break;
+
+ case OMP_CONTINUE:
+ pp_string (buffer, "OMP_CONTINUE");
+ is_expr = false;
+ break;
+
+ case OMP_CLAUSE:
+ dump_omp_clause (buffer, node, spc, flags);
+ is_expr = false;
+ break;
+
case REDUC_MAX_EXPR:
pp_string (buffer, " REDUC_MAX_EXPR < ");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
pp_string (buffer, " > ");
break;
+ case VEC_WIDEN_MULT_HI_EXPR:
+ pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_WIDEN_MULT_LO_EXPR:
+ pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_UNPACK_HI_EXPR:
+ pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_UNPACK_LO_EXPR:
+ pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_PACK_MOD_EXPR:
+ pp_string (buffer, " VEC_PACK_MOD_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_PACK_SAT_EXPR:
+ pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
case BLOCK:
{
tree t;
}
break;
+ case VEC_EXTRACT_EVEN_EXPR:
+ pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_EXTRACT_ODD_EXPR:
+ pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_INTERLEAVE_HIGH_EXPR:
+ pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case VEC_INTERLEAVE_LOW_EXPR:
+ pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
default:
NIY;
}
return 1;
case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
case INIT_EXPR:
return 2;
case RROTATE_EXPR:
return 11;
+ case WIDEN_SUM_EXPR:
case PLUS_EXPR:
case MINUS_EXPR:
return 12;
+ case VEC_WIDEN_MULT_HI_EXPR:
+ case VEC_WIDEN_MULT_LO_EXPR:
+ case WIDEN_MULT_EXPR:
+ case DOT_PROD_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case NOP_EXPR:
case CONVERT_EXPR:
case FIX_TRUNC_EXPR:
- case FIX_CEIL_EXPR:
- case FIX_FLOOR_EXPR:
- case FIX_ROUND_EXPR:
case TARGET_EXPR:
return 14;
case REDUC_PLUS_EXPR:
case VEC_LSHIFT_EXPR:
case VEC_RSHIFT_EXPR:
+ case VEC_UNPACK_HI_EXPR:
+ case VEC_UNPACK_LO_EXPR:
+ case VEC_PACK_MOD_EXPR:
+ case VEC_PACK_SAT_EXPR:
return 16;
case SAVE_EXPR:
switch (code)
{
case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
return "=";
case TRUTH_OR_EXPR:
case REDUC_PLUS_EXPR:
return "r+";
+ case WIDEN_SUM_EXPR:
+ return "w+";
+
+ case WIDEN_MULT_EXPR:
+ return "w*";
+
case NEGATE_EXPR:
case MINUS_EXPR:
return "-";
gcc_assert (TREE_CODE (node) == CALL_EXPR);
- op0 = TREE_OPERAND (node, 0);
+ op0 = CALL_EXPR_FN (node);
if (TREE_CODE (op0) == NON_LVALUE_EXPR)
op0 = TREE_OPERAND (op0, 0);
pp_string (buffer, "\\'");
break;
- case '\0':
- pp_string (buffer, "\\0");
- break;
+ /* No need to handle \0; the loop terminates on \0. */
case '\1':
pp_string (buffer, "\\1");
INDENT (spc);
}
+
static void
dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
{
- tree use;
- use_operand_p use_p;
- def_operand_p def_p;
- use_operand_p kill_p;
- ssa_op_iter iter;
+ struct voptype_d *vdefs;
+ struct voptype_d *vuses;
+ int i, n;
- if (!ssa_operands_active ())
+ if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
return;
- FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
+ /* Even if the statement doesn't have virtual operators yet, it may
+ contain symbol information (this happens before aliases have been
+ computed). */
+ if ((flags & TDF_MEMSYMS)
+ && VUSE_OPS (stmt) == NULL
+ && VDEF_OPS (stmt) == NULL)
{
- pp_string (buffer, "# ");
- dump_generic_node (buffer, DEF_FROM_PTR (def_p),
- spc + 2, flags, false);
- pp_string (buffer, " = V_MAY_DEF <");
- dump_generic_node (buffer, USE_FROM_PTR (use_p),
- spc + 2, flags, false);
- pp_string (buffer, ">;");
- newline_and_indent (buffer, spc);
+ if (LOADED_SYMS (stmt))
+ {
+ pp_string (buffer, "# LOADS: ");
+ dump_symbols (buffer, LOADED_SYMS (stmt), flags);
+ newline_and_indent (buffer, spc);
+ }
+
+ if (STORED_SYMS (stmt))
+ {
+ pp_string (buffer, "# STORES: ");
+ dump_symbols (buffer, STORED_SYMS (stmt), flags);
+ newline_and_indent (buffer, spc);
+ }
+
+ return;
}
- FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
+ vuses = VUSE_OPS (stmt);
+ while (vuses)
{
- pp_string (buffer, "# ");
- dump_generic_node (buffer, DEF_FROM_PTR (def_p),
- spc + 2, flags, false);
- pp_string (buffer, " = V_MUST_DEF <");
- dump_generic_node (buffer, USE_FROM_PTR (kill_p),
- spc + 2, flags, false);
- pp_string (buffer, ">;");
+ pp_string (buffer, "# VUSE <");
+
+ n = VUSE_NUM (vuses);
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+
+ pp_string (buffer, ">");
+
+ if (flags & TDF_MEMSYMS)
+ dump_symbols (buffer, LOADED_SYMS (stmt), flags);
+
newline_and_indent (buffer, spc);
+ vuses = vuses->next;
}
- FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
+ vdefs = VDEF_OPS (stmt);
+ while (vdefs)
{
- pp_string (buffer, "# VUSE <");
- dump_generic_node (buffer, use, spc + 2, flags, false);
- pp_string (buffer, ">;");
+ pp_string (buffer, "# ");
+ dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
+ pp_string (buffer, " = VDEF <");
+
+ n = VDEF_NUM (vdefs);
+ for (i = 0; i < n; i++)
+ {
+ dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
+ if (i < n - 1)
+ pp_string (buffer, ", ");
+ }
+
+ pp_string (buffer, ">");
+
+ if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
+ dump_symbols (buffer, STORED_SYMS (stmt), flags);
+
newline_and_indent (buffer, spc);
+ vdefs = vdefs->next;
}
}
+
/* Dumps basic block BB to FILE with details described by FLAGS and
indented by INDENT spaces. */
pp_newline (buffer);
}
-/* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
- FLAGS indented by INDENT spaces. */
+/* Dump PHI nodes of basic block BB to BUFFER with details described
+ by FLAGS and indented by INDENT spaces. */
static void
dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
}
}
+
/* Dump jump to basic block BB that is represented implicitly in the cfg
to BUFFER. */
INDENT (curr_indent);
dump_generic_node (buffer, stmt, curr_indent, flags, true);
pp_newline (buffer);
+ dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
}
dump_implicit_edges (buffer, bb, indent, flags);
OSDN Git Service
