/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
pp_string (buffer, "<<< Unknown tree: ");
pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
- if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (node))))
+ if (EXPR_P (node))
{
len = first_rtl_op (TREE_CODE (node));
for (i = 0; i < len; ++i)
{
if (TREE_CODE (node) == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
- pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
+ pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
LABEL_DECL_UID (node));
else
{
char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
- pp_printf (buffer, "<%c%u>", c, DECL_UID (node));
+ pp_printf (buffer, "%c.%u", c, DECL_UID (node));
}
}
}
+/* Like the above, but used for pretty printing function calls. */
+
+static void
+dump_function_name (pretty_printer *buffer, tree node)
+{
+ if (DECL_NAME (node))
+ PRINT_FUNCTION_NAME (node);
+ else
+ dump_decl_name (buffer, node, 0);
+}
+
/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
FLAGS are as in dump_generic_node. */
}
break;
- case TREE_VEC:
+ case TREE_BINFO:
dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
+
+ case TREE_VEC:
+ {
+ size_t i;
+ if (TREE_VEC_LENGTH (node) > 0)
+ {
+ size_t len = TREE_VEC_LENGTH (node);
+ for (i = 0; i < len - 1; i++)
+ {
+ dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
+ false);
+ pp_character (buffer, ',');
+ pp_space (buffer);
+ }
+ dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
+ flags, false);
+ }
+ }
break;
case BLOCK:
case CHAR_TYPE:
{
unsigned int quals = TYPE_QUALS (node);
- char class;
+ enum tree_code_class class;
if (quals & TYPE_QUAL_CONST)
pp_string (buffer, "const ");
class = TREE_CODE_CLASS (TREE_CODE (node));
- if (class == 'd')
+ if (class == tcc_declaration)
{
if (DECL_NAME (node))
dump_decl_name (buffer, node, flags);
else
pp_string (buffer, "<unnamed type decl>");
}
- else if (class == 't')
+ else if (class == tcc_type)
{
if (TYPE_NAME (node))
{
&& DECL_NAME (TYPE_NAME (node)))
dump_decl_name (buffer, TYPE_NAME (node), flags);
else
- pp_string (buffer, "<unnamed type>");
+ pp_string (buffer, "<unnamed type>");
+ }
+ else if (TREE_CODE (node) == VECTOR_TYPE)
+ {
+ pp_string (buffer, "vector ");
+ dump_generic_node (buffer, TREE_TYPE (node),
+ spc, flags, false);
}
else
pp_string (buffer, "<unnamed type>");
pp_string (buffer, "volatile");
else if (quals & TYPE_QUAL_RESTRICT)
pp_string (buffer, " restrict");
+
+ if (TYPE_REF_CAN_ALIAS_ALL (node))
+ pp_string (buffer, " {ref-all}");
}
break;
pp_string (buffer, str);
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
- op0 = component_ref_field_offset (node);
- if (op0 && TREE_CODE (op0) != INTEGER_CST)
+ if (TREE_CODE (op0) != VALUE_HANDLE)
{
- pp_string (buffer, "{off: ");
- dump_generic_node (buffer, op0, spc, flags, false);
- pp_character (buffer, '}');
+ op0 = component_ref_field_offset (node);
+ if (op0 && TREE_CODE (op0) != INTEGER_CST)
+ {
+ pp_string (buffer, "{off: ");
+ dump_generic_node (buffer, op0, spc, flags, false);
+ pp_character (buffer, '}');
+ }
}
break;
pp_character (buffer, ')');
/* The lowered cond_exprs should always be printed in full. */
if (COND_EXPR_THEN (node)
- && TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR
+ && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
+ || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
&& COND_EXPR_ELSE (node)
- && TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)
+ && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
+ || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
{
pp_space (buffer);
dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
case ADDR_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
+ case ALIGN_INDIRECT_REF:
+ case MISALIGNED_INDIRECT_REF:
case INDIRECT_REF:
if (TREE_CODE (node) == ADDR_EXPR
&& (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
}
else
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+
+ if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
+ {
+ pp_string (buffer, "{misalignment: ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_character (buffer, '}');
+ }
break;
case POSTDECREMENT_EXPR:
{
pp_character (buffer, '(');
dump_generic_node (buffer, type, spc, flags, false);
- pp_string (buffer, ")");
+ pp_string (buffer, ") ");
}
if (op_prio (op0) < op_prio (node))
pp_character (buffer, '(');
pp_string (buffer, " [non-local]");
break;
- case LABELED_BLOCK_EXPR:
- op0 = LABELED_BLOCK_LABEL (node);
- /* If this is for break or continue, don't bother printing it. */
- if (DECL_NAME (op0))
- {
- const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
- if (strcmp (name, "break") == 0
- || strcmp (name, "continue") == 0)
- {
- dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc, flags, false);
- break;
- }
- }
- dump_generic_node (buffer, LABELED_BLOCK_LABEL (node), spc, flags, false);
- pp_string (buffer, ": {");
- if (!(flags & TDF_SLIM))
- newline_and_indent (buffer, spc+2);
- dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc+2, flags, true);
- if (!flags)
- newline_and_indent (buffer, spc);
- pp_character (buffer, '}');
- is_expr = false;
- break;
-
- case EXIT_BLOCK_EXPR:
- op0 = LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (node));
- /* If this is for a break or continue, print it accordingly. */
- if (DECL_NAME (op0))
- {
- const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
- if (strcmp (name, "break") == 0
- || strcmp (name, "continue") == 0)
- {
- pp_string (buffer, name);
- break;
- }
- }
- pp_string (buffer, "<<<exit block ");
- dump_generic_node (buffer, op0, spc, flags, false);
- pp_string (buffer, ">>>");
- break;
-
case EXC_PTR_EXPR:
pp_string (buffer, "<<<exception object>>>");
break;
case GOTO_EXPR:
op0 = GOTO_DESTINATION (node);
- if (TREE_CODE (op0) != SSA_NAME
- && DECL_P (op0)
- && DECL_NAME (op0))
+ if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
{
const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
if (strcmp (name, "break") == 0
is_stmt = false;
break;
+ case REALIGN_LOAD_EXPR:
+ pp_string (buffer, "REALIGN_LOAD <");
+ 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 VEC_COND_EXPR:
+ pp_string (buffer, " VEC_COND_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;
+
default:
NIY;
}
pp_character (buffer, '[');
if (TYPE_DOMAIN (tmp))
{
- if (TREE_CODE (TYPE_SIZE (tmp)) == INTEGER_CST)
- pp_wide_integer (buffer,
- TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
- TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
- else
- dump_generic_node (buffer, TYPE_SIZE_UNIT (tmp), spc, flags,
- false);
+ if (TYPE_MIN_VALUE (TYPE_DOMAIN (tmp))
+ && !integer_zerop (TYPE_MIN_VALUE (TYPE_DOMAIN (tmp))))
+ {
+ dump_generic_node (buffer,
+ TYPE_MIN_VALUE (TYPE_DOMAIN (tmp)),
+ spc, flags, false);
+ pp_string (buffer, " .. ");
+ }
+
+ if (TYPE_MAX_VALUE (TYPE_DOMAIN (tmp)))
+ dump_generic_node (buffer, TYPE_MAX_VALUE (TYPE_DOMAIN (tmp)),
+ spc, flags, false);
}
pp_character (buffer, ']');
tmp = TREE_TYPE (tmp);
dump_generic_node (buffer, t, spc, flags, false);
}
+ if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
+ {
+ pp_string (buffer, " __asm__ ");
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
+ pp_character (buffer, ')');
+ }
+
/* The initial value of a function serves to determine wether the function
is declared or defined. So the following does not apply to function
nodes. */
case PREINCREMENT_EXPR:
case PREDECREMENT_EXPR:
case NEGATE_EXPR:
+ case ALIGN_INDIRECT_REF:
+ case MISALIGNED_INDIRECT_REF:
case INDIRECT_REF:
case ADDR_EXPR:
case FLOAT_EXPR:
static const char *
op_symbol (tree op)
{
- if (op == NULL)
- abort ();
+ gcc_assert (op);
switch (TREE_CODE (op))
{
case INDIRECT_REF:
return "*";
+ case ALIGN_INDIRECT_REF:
+ return "A*";
+
+ case MISALIGNED_INDIRECT_REF:
+ return "M*";
+
case TRUNC_DIV_EXPR:
+ case RDIV_EXPR:
+ return "/";
+
case CEIL_DIV_EXPR:
+ return "/[cl]";
+
case FLOOR_DIV_EXPR:
+ return "/[fl]";
+
case ROUND_DIV_EXPR:
- case RDIV_EXPR:
+ return "/[rd]";
+
case EXACT_DIV_EXPR:
- return "/";
+ return "/[ex]";
case TRUNC_MOD_EXPR:
+ return "%";
+
case CEIL_MOD_EXPR:
+ return "%[cl]";
+
case FLOOR_MOD_EXPR:
+ return "%[fl]";
+
case ROUND_MOD_EXPR:
- return "%";
+ return "%[rd]";
case PREDECREMENT_EXPR:
return " --";
{
tree op0;
- if (TREE_CODE (node) != CALL_EXPR)
- abort ();
+ gcc_assert (TREE_CODE (node) == CALL_EXPR);
op0 = TREE_OPERAND (node, 0);
{
case VAR_DECL:
case PARM_DECL:
- PRINT_FUNCTION_NAME (op0);
+ dump_function_name (buffer, op0);
break;
case ADDR_EXPR:
/* The function is a pointer contained in a structure. */
if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
- PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 1));
+ dump_function_name (buffer, TREE_OPERAND (op0, 1));
else
dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
/* else
case ARRAY_REF:
if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
- PRINT_FUNCTION_NAME (TREE_OPERAND (op0, 0));
+ dump_function_name (buffer, TREE_OPERAND (op0, 0));
else
dump_generic_node (buffer, op0, 0, 0, false);
break;
static void
dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
{
- tree use, def;
+ tree use;
use_operand_p use_p;
def_operand_p def_p;
+ use_operand_p kill_p;
ssa_op_iter iter;
FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
newline_and_indent (buffer, spc);
}
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMUSTDEF)
+ FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
{
- pp_string (buffer, "# V_MUST_DEF <");
- dump_generic_node (buffer, def, spc + 2, flags, false);
+ 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, ">;");
newline_and_indent (buffer, spc);
}
{
edge e;
tree stmt;
+ edge_iterator ei;
if (flags & TDF_BLOCKS)
{
pp_string (buffer, "# PRED:");
pp_write_text_to_stream (buffer);
- for (e = bb->pred; e; e = e->pred_next)
- if (flags & TDF_SLIM)
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ if (flags & TDF_SLIM)
{
pp_string (buffer, " ");
if (e->src == ENTRY_BLOCK_PTR)
dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
{
edge e;
+ edge_iterator ei;
INDENT (indent);
pp_string (buffer, "# SUCC:");
pp_write_text_to_stream (buffer);
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (flags & TDF_SLIM)
{
pp_string (buffer, " ");
int flags)
{
edge e;
+ edge_iterator ei;
/* If there is a fallthru edge, we may need to add an artificial goto to the
dump. */
- for (e = bb->succ; e; e = e->succ_next)
+ FOR_EACH_EDGE (e, ei, bb->succs)
if (e->flags & EDGE_FALLTHRU)
break;
if (e && e->dest != bb->next_bb)