/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
#include "tm.h"
#include "tree.h"
#include "output.h"
-#include "diagnostic.h"
-#include "real.h"
+#include "tree-pretty-print.h"
#include "hashtab.h"
#include "tree-flow.h"
#include "langhooks.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 const char *op_symbol (const_tree);
static void pretty_print_string (pretty_printer *, const char*);
-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_struct_decl (pretty_printer *, const_tree, int, int);
#define NIY do_niy(buffer,node)
-#define PRINT_FUNCTION_NAME(NODE) pp_printf \
- (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ? \
- lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
- lang_hooks.decl_printable_name (NODE, 1))
-
static pretty_printer buffer;
static int initialized = 0;
}
}
- pp_string (buffer, " >>>\n");
+ pp_string (buffer, " >>>");
}
/* Debugging function to print out a generic expression. */
-void
+DEBUG_FUNCTION void
debug_generic_expr (tree t)
{
print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
/* Debugging function to print out a generic statement. */
-void
+DEBUG_FUNCTION void
debug_generic_stmt (tree t)
{
print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
/* Debugging function to print out a chain of trees . */
-void
+DEBUG_FUNCTION void
debug_tree_chain (tree t)
{
+ struct pointer_set_t *seen = pointer_set_create ();
+
while (t)
- {
- print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
- fprintf(stderr, " ");
- t = TREE_CHAIN (t);
- }
+ {
+ print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
+ fprintf (stderr, " ");
+ t = TREE_CHAIN (t);
+ if (pointer_set_insert (seen, t))
+ {
+ fprintf (stderr, "... [cycled back to ");
+ print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
+ fprintf (stderr, "]");
+ break;
+ }
+ }
fprintf (stderr, "\n");
+
+ pointer_set_destroy (seen);
}
/* Prints declaration DECL to the FILE with details specified by FLAGS. */
static void
dump_decl_name (pretty_printer *buffer, tree node, int flags)
{
- tree t = node;
-
- if (DECL_NAME (t))
- pp_tree_identifier (buffer, DECL_NAME (t));
- if ((flags & TDF_UID)
- || DECL_NAME (t) == NULL_TREE)
+ if (DECL_NAME (node))
{
- if (TREE_CODE (t) == LABEL_DECL
- && LABEL_DECL_UID (t) != -1)
- pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (t));
+ if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))
+ pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node));
else
+ pp_tree_identifier (buffer, DECL_NAME (node));
+ }
+ if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE)
+ {
+ if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
+ pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node));
+ else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
{
- char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
- pp_printf (buffer, "%c.%u", c, DECL_UID (t));
+ if (flags & TDF_NOUID)
+ pp_string (buffer, "D#xxxx");
+ else
+ pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node));
+ }
+ else
+ {
+ char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
+ if (flags & TDF_NOUID)
+ pp_printf (buffer, "%c.xxxx", c);
+ else
+ pp_printf (buffer, "%c.%u", c, DECL_UID (node));
}
}
+ if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
+ {
+ if (flags & TDF_NOUID)
+ pp_printf (buffer, "ptD.xxxx");
+ else
+ pp_printf (buffer, "ptD.%u", DECL_PT_UID (node));
+ }
}
/* Like the above, but used for pretty printing function calls. */
static void
-dump_function_name (pretty_printer *buffer, tree node)
+dump_function_name (pretty_printer *buffer, tree node, int flags)
{
- if (DECL_NAME (node))
- PRINT_FUNCTION_NAME (node);
+ if (TREE_CODE (node) == NOP_EXPR)
+ node = TREE_OPERAND (node, 0);
+ if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
+ pp_string (buffer, lang_hooks.decl_printable_name (node, 1));
else
- dump_decl_name (buffer, node, 0);
+ dump_decl_name (buffer, node, flags);
}
/* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and
{
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,
+ dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
flags, false);
}
}
else if (quals & TYPE_QUAL_RESTRICT)
pp_string (buffer, "restrict ");
+ if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
+ {
+ pp_string (buffer, "<address-space-");
+ pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
+ pp_string (buffer, "> ");
+ }
+
tclass = TREE_CODE_CLASS (TREE_CODE (node));
if (tclass == tcc_declaration)
}
else if (TREE_CODE (node) == VECTOR_TYPE)
{
- pp_string (buffer, "vector ");
+ pp_string (buffer, "vector");
+ pp_character (buffer, '(');
+ pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node));
+ pp_string (buffer, ") ");
dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
}
else if (TREE_CODE (node) == INTEGER_TYPE)
pp_string (buffer, str);
if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
dump_decl_name (buffer, TYPE_NAME (node), flags);
+ else if (flags & TDF_NOUID)
+ pp_printf (buffer, "<Txxxx>");
else
pp_printf (buffer, "<T%x>", TYPE_UID (node));
if (quals & TYPE_QUAL_RESTRICT)
pp_string (buffer, " restrict");
+ if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
+ {
+ pp_string (buffer, " <address-space-");
+ pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
+ pp_string (buffer, ">");
+ }
+
if (TYPE_REF_CAN_ALIAS_ALL (node))
pp_string (buffer, " {ref-all}");
}
NIY;
break;
+ case MEM_REF:
+ {
+ if (integer_zerop (TREE_OPERAND (node, 1))
+ /* Same pointer types, but ignoring POINTER_TYPE vs.
+ REFERENCE_TYPE. */
+ && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
+ == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
+ && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
+ == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
+ && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
+ == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
+ && (TYPE_QUALS (TREE_TYPE (TREE_OPERAND (node, 0)))
+ == TYPE_QUALS (TREE_TYPE (TREE_OPERAND (node, 1))))
+ /* Same value types ignoring qualifiers. */
+ && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
+ == TYPE_MAIN_VARIANT
+ (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))))
+ {
+ if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
+ {
+ pp_string (buffer, "*");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0),
+ spc, flags, false);
+ }
+ else
+ dump_generic_node (buffer,
+ TREE_OPERAND (TREE_OPERAND (node, 0), 0),
+ spc, flags, false);
+ }
+ else
+ {
+ pp_string (buffer, "MEM[");
+ pp_string (buffer, "(");
+ dump_generic_node (buffer, TREE_TYPE (TREE_OPERAND (node, 1)),
+ spc, flags | TDF_SLIM, false);
+ pp_string (buffer, ")");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0),
+ spc, flags, false);
+ if (!integer_zerop (TREE_OPERAND (node, 1)))
+ {
+ pp_string (buffer, " + ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1),
+ spc, flags, false);
+ }
+ pp_string (buffer, "]");
+ }
+ break;
+ }
+
case TARGET_MEM_REF:
{
const char *sep = "";
}
if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
dump_decl_name (buffer, TYPE_NAME (node), flags);
+ else if (flags & TDF_NOUID)
+ pp_printf (buffer, "<Txxxx>");
else
pp_printf (buffer, "<T%x>", TYPE_UID (node));
dump_function_declaration (buffer, node, spc, flags);
if (DECL_NAME (node))
dump_decl_name (buffer, node, flags);
else if (LABEL_DECL_UID (node) != -1)
- pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
+ pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
else
- pp_printf (buffer, "<D.%u>", DECL_UID (node));
+ {
+ if (flags & TDF_NOUID)
+ pp_string (buffer, "<D.xxxx>");
+ else
+ pp_printf (buffer, "<D.%u>", DECL_UID (node));
+ }
break;
case TYPE_DECL:
}
if (DECL_NAME (node))
dump_decl_name (buffer, node, flags);
- else
+ else if (TYPE_NAME (TREE_TYPE (node)) != node)
{
if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
|| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
}
}
+ else
+ pp_string (buffer, "<anon>");
break;
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
+ case DEBUG_EXPR_DECL:
case NAMESPACE_DECL:
dump_decl_name (buffer, node, flags);
break;
case COMPONENT_REF:
op0 = TREE_OPERAND (node, 0);
str = ".";
- if (TREE_CODE (op0) == INDIRECT_REF)
+ if (op0
+ && (TREE_CODE (op0) == INDIRECT_REF
+ || (TREE_CODE (op0) == MEM_REF
+ && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
+ && integer_zerop (TREE_OPERAND (op0, 1))
+ /* Same pointer types, but ignoring POINTER_TYPE vs.
+ REFERENCE_TYPE. */
+ && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
+ == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
+ && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
+ == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
+ && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
+ == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
+ && (TYPE_QUALS (TREE_TYPE (TREE_OPERAND (op0, 0)))
+ == TYPE_QUALS (TREE_TYPE (TREE_OPERAND (op0, 1))))
+ /* Same value types ignoring qualifiers. */
+ && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
+ == TYPE_MAIN_VARIANT
+ (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))))))
{
op0 = TREE_OPERAND (op0, 0);
str = "->";
{
pp_newline (buffer);
- for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
+ for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
{
print_declaration (buffer, op0, spc+2, flags);
pp_newline (buffer);
break;
case CALL_EXPR:
- print_call_name (buffer, node);
+ print_call_name (buffer, CALL_EXPR_FN (node), flags);
/* Print parameters. */
pp_space (buffer);
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
NIY;
break;
+ case ADDR_SPACE_CONVERT_EXPR:
case FIXED_CONVERT_EXPR:
case FIX_TRUNC_EXPR:
case FLOAT_EXPR:
pp_string (buffer, " [non-local]");
break;
- case EXC_PTR_EXPR:
- pp_string (buffer, "<<<exception object>>>");
- break;
-
- case FILTER_EXPR:
- pp_string (buffer, "<<<filter object>>>");
- break;
-
case LOOP_EXPR:
pp_string (buffer, "while (1)");
if (!(flags & TDF_SLIM))
dump_generic_node (buffer, op0, spc, flags, false);
break;
- case RESX_EXPR:
- pp_string (buffer, "resx ");
- dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
- break;
-
case ASM_EXPR:
pp_string (buffer, "__asm__");
if (ASM_VOLATILE_P (node))
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, " > ");
break;
+ case WIDEN_MULT_PLUS_EXPR:
+ pp_string (buffer, " WIDEN_MULT_PLUS_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 WIDEN_MULT_MINUS_EXPR:
+ pp_string (buffer, " WIDEN_MULT_MINUS_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);
case OMP_SECTION:
pp_string (buffer, "#pragma omp section");
goto dump_omp_body;
-
+
case OMP_MASTER:
pp_string (buffer, "#pragma omp master");
goto dump_omp_body;
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, "static ");
/* Print the type and name. */
- if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
+ if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
{
tree tmp;
print_declaration (buffer, tmp, spc+2, flags);
pp_newline (buffer);
}
- tmp = TREE_CHAIN (tmp);
+ tmp = DECL_CHAIN (tmp);
}
}
INDENT (spc);
case VEC_WIDEN_MULT_LO_EXPR:
case WIDEN_MULT_EXPR:
case DOT_PROD_EXPR:
+ case WIDEN_MULT_PLUS_EXPR:
+ case WIDEN_MULT_MINUS_EXPR:
case MULT_EXPR:
case TRUNC_DIV_EXPR:
case CEIL_DIV_EXPR:
case PREINCREMENT_EXPR:
case PREDECREMENT_EXPR:
case NEGATE_EXPR:
- case ALIGN_INDIRECT_REF:
case MISALIGNED_INDIRECT_REF:
case INDIRECT_REF:
case ADDR_EXPR:
case POINTER_PLUS_EXPR:
return "+";
-
+
case PLUS_EXPR:
return "+";
case INDIRECT_REF:
return "*";
- case ALIGN_INDIRECT_REF:
- return "A*";
-
case MISALIGNED_INDIRECT_REF:
return "M*";
return op_symbol_code (TREE_CODE (op));
}
-/* Prints the name of a CALL_EXPR. */
+/* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or
+ the gimple_call_fn of a GIMPLE_CALL. */
-static void
-print_call_name (pretty_printer *buffer, const_tree node)
+void
+print_call_name (pretty_printer *buffer, tree node, int flags)
{
- tree op0;
-
- gcc_assert (TREE_CODE (node) == CALL_EXPR);
-
- op0 = CALL_EXPR_FN (node);
+ tree op0 = node;
if (TREE_CODE (op0) == NON_LVALUE_EXPR)
op0 = TREE_OPERAND (op0, 0);
+ again:
switch (TREE_CODE (op0))
{
case VAR_DECL:
case PARM_DECL:
- dump_function_name (buffer, op0);
+ case FUNCTION_DECL:
+ dump_function_name (buffer, op0, flags);
break;
case ADDR_EXPR:
case INDIRECT_REF:
case NOP_EXPR:
- dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
- break;
+ op0 = TREE_OPERAND (op0, 0);
+ goto again;
case COND_EXPR:
pp_string (buffer, "(");
- dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
+ dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);
pp_string (buffer, ") ? ");
- dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
+ dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);
pp_string (buffer, " : ");
- dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
- break;
-
- case COMPONENT_REF:
- /* 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)
- dump_function_name (buffer, TREE_OPERAND (op0, 1));
- else
- dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
- /* else
- We can have several levels of structures and a function
- pointer inside. This is not implemented yet... */
- /* NIY;*/
+ dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false);
break;
case ARRAY_REF:
if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
- dump_function_name (buffer, TREE_OPERAND (op0, 0));
+ dump_function_name (buffer, TREE_OPERAND (op0, 0), flags);
else
- dump_generic_node (buffer, op0, 0, 0, false);
+ dump_generic_node (buffer, op0, 0, flags, false);
break;
+ case MEM_REF:
+ if (integer_zerop (TREE_OPERAND (op0, 1)))
+ {
+ op0 = TREE_OPERAND (op0, 0);
+ goto again;
+ }
+ /* Fallthru. */
+ case COMPONENT_REF:
case SSA_NAME:
case OBJ_TYPE_REF:
- dump_generic_node (buffer, op0, 0, 0, false);
+ dump_generic_node (buffer, op0, 0, flags, false);
break;
default:
pp_newline (buffer);
INDENT (spc);
}
+
+/* Handle a %K format for TEXT. Separate from default_tree_printer so
+ it can also be used in front ends.
+ %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
+*/
+
+void
+percent_K_format (text_info *text)
+{
+ tree t = va_arg (*text->args_ptr, tree), block;
+ gcc_assert (text->locus != NULL);
+ *text->locus = EXPR_LOCATION (t);
+ gcc_assert (pp_ti_abstract_origin (text) != NULL);
+ block = TREE_BLOCK (t);
+ *pp_ti_abstract_origin (text) = NULL;
+ while (block
+ && TREE_CODE (block) == BLOCK
+ && BLOCK_ABSTRACT_ORIGIN (block))
+ {
+ tree ao = BLOCK_ABSTRACT_ORIGIN (block);
+
+ while (TREE_CODE (ao) == BLOCK
+ && BLOCK_ABSTRACT_ORIGIN (ao)
+ && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
+ ao = BLOCK_ABSTRACT_ORIGIN (ao);
+
+ if (TREE_CODE (ao) == FUNCTION_DECL)
+ {
+ *pp_ti_abstract_origin (text) = block;
+ break;
+ }
+ block = BLOCK_SUPERCONTEXT (block);
+ }
+}
+
+/* Print the identifier ID to PRETTY-PRINTER. */
+
+void
+pp_base_tree_identifier (pretty_printer *pp, tree id)
+{
+ if (pp_translate_identifiers (pp))
+ {
+ const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
+ pp_append_text (pp, text, text + strlen (text));
+ }
+ else
+ pp_append_text (pp, IDENTIFIER_POINTER (id),
+ IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
+}
OSDN Git Service
