/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
-#include "errors.h"
#include "tree.h"
#include "diagnostic.h"
#include "real.h"
#include "tree-flow.h"
#include "langhooks.h"
#include "tree-iterator.h"
+#include "tree-chrec.h"
+#include "tree-pass.h"
/* Local functions, macros and variables. */
static int op_prio (tree);
+static const char *op_symbol_1 (enum tree_code);
static const char *op_symbol (tree);
static void pretty_print_string (pretty_printer *, const char*);
static void print_call_name (pretty_printer *, tree);
lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
lang_hooks.decl_printable_name (NODE, 1))
-#define MASK_POINTER(P) ((unsigned)((unsigned long)(P) & 0xffff))
-
static pretty_printer buffer;
static int initialized = 0;
-static bool dumping_stmts;
/* Try to print something for an unknown tree code. */
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));
+ len = TREE_CODE_LENGTH (TREE_CODE (node));
for (i = 0; i < len; ++i)
{
newline_and_indent (buffer, 2);
fprintf (stderr, "\n");
}
+void
+debug_tree_chain (tree t)
+{
+ while (t)
+ {
+ print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
+ fprintf(stderr, " ");
+ t = TREE_CHAIN (t);
+ }
+ fprintf (stderr, "\n");
+}
+
/* Prints declaration DECL to the FILE with details specified by FLAGS. */
void
print_generic_decl (FILE *file, tree decl, int flags)
{
maybe_init_pretty_print (file);
- dumping_stmts = true;
print_declaration (&buffer, decl, 2, flags);
pp_write_text_to_stream (&buffer);
}
print_generic_stmt (FILE *file, tree t, int flags)
{
maybe_init_pretty_print (file);
- dumping_stmts = true;
dump_generic_node (&buffer, t, 0, flags, true);
pp_flush (&buffer);
}
int i;
maybe_init_pretty_print (file);
- dumping_stmts = true;
for (i = 0; i < indent; i++)
pp_space (&buffer);
print_generic_expr (FILE *file, tree t, int flags)
{
maybe_init_pretty_print (file);
- dumping_stmts = false;
dump_generic_node (&buffer, t, 0, flags, false);
}
static void
dump_decl_name (pretty_printer *buffer, tree node, int flags)
{
- if (DECL_NAME (node))
- pp_tree_identifier (buffer, DECL_NAME (node));
+ tree t = node;
+ if (DECL_NAME (t))
+ pp_tree_identifier (buffer, DECL_NAME (t));
if ((flags & TDF_UID)
- || DECL_NAME (node) == NULL_TREE)
+ || DECL_NAME (t) == NULL_TREE)
{
- if (TREE_CODE (node) == LABEL_DECL
- && LABEL_DECL_UID (node) != -1)
- pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
- LABEL_DECL_UID (node));
+ 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));
+ }
+ }
+}
+
+/* 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. */
+
+static void
+dump_function_declaration (pretty_printer *buffer, tree node,
+ int spc, int flags)
+{
+ bool wrote_arg = false;
+ tree arg;
+
+ pp_space (buffer);
+ pp_character (buffer, '(');
+
+ /* Print the argument types. The last element in the list is a VOID_TYPE.
+ The following avoids printing the last element. */
+ arg = TYPE_ARG_TYPES (node);
+ while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
+ {
+ wrote_arg = true;
+ dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
+ arg = TREE_CHAIN (arg);
+ if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
+ {
+ pp_character (buffer, ',');
+ pp_space (buffer);
+ }
+ }
+
+ if (!wrote_arg)
+ pp_string (buffer, "void");
+
+ pp_character (buffer, ')');
+}
+
+/* Dump the domain associated with an array. */
+
+static void
+dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
+{
+ pp_character (buffer, '[');
+ if (domain)
+ {
+ tree min = TYPE_MIN_VALUE (domain);
+ tree max = TYPE_MAX_VALUE (domain);
+
+ if (min && max
+ && integer_zerop (min)
+ && host_integerp (max, 0))
+ pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
else
- pp_printf (buffer, "<D%u>", DECL_UID (node));
+ {
+ if (min)
+ dump_generic_node (buffer, min, spc, flags, false);
+ pp_character (buffer, ':');
+ if (max)
+ dump_generic_node (buffer, max, spc, flags, false);
+ }
+ }
+ else
+ pp_string (buffer, "<unknown>");
+ pp_character (buffer, ']');
+}
+
+
+/* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in
+ dump_generic_node. */
+
+static void
+dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
+{
+ const char *name;
+
+ switch (OMP_CLAUSE_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_IF:
+ pp_string (buffer, "if(");
+ dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (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_NOWAIT:
+ pp_string (buffer, "nowait");
+ break;
+ case OMP_CLAUSE_ORDERED:
+ pp_string (buffer, "ordered");
+ 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_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;
+ pp_space (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
{
tree type;
tree op0, op1;
- const char* str;
+ const char *str;
bool is_expr;
if (node == NULL_TREE)
if (TREE_CODE (node) != ERROR_MARK
&& is_gimple_stmt (node)
&& (flags & TDF_VOPS)
- && stmt_ann (node))
+ && stmt_ann (node)
+ && TREE_CODE (node) != PHI_NODE)
dump_vops (buffer, node, spc, flags);
- if (dumping_stmts
- && (flags & TDF_LINENO)
- && EXPR_HAS_LOCATION (node))
+ if (is_stmt && (flags & TDF_STMTADDR))
+ pp_printf (buffer, "<&%p> ", (void *)node);
+
+ if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
{
+ expanded_location xloc = expand_location (EXPR_LOCATION (node));
pp_character (buffer, '[');
- if (EXPR_FILENAME (node))
+ if (xloc.file)
{
- pp_string (buffer, EXPR_FILENAME (node));
+ pp_string (buffer, xloc.file);
pp_string (buffer, " : ");
}
- pp_decimal_int (buffer, EXPR_LINENO (node));
+ pp_decimal_int (buffer, xloc.line);
pp_string (buffer, "] ");
}
}
break;
- case TREE_VEC:
+ case TREE_BINFO:
dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
- break;
- case BLOCK:
- NIY;
+ 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 VOID_TYPE:
case VECTOR_TYPE:
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
- 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>");
if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
{
tree fnode = TREE_TYPE (node);
+
dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
pp_space (buffer);
pp_character (buffer, '(');
pp_printf (buffer, "<T%x>", TYPE_UID (node));
pp_character (buffer, ')');
- pp_space (buffer);
- pp_character (buffer, '(');
- /* Print the argument types. The last element in the list is a
- VOID_TYPE. The following avoid to print the last element. */
- {
- tree tmp = TYPE_ARG_TYPES (fnode);
- while (tmp && TREE_CHAIN (tmp) && tmp != error_mark_node)
- {
- dump_generic_node (buffer, TREE_VALUE (tmp), spc, flags, false);
- tmp = TREE_CHAIN (tmp);
- if (TREE_CHAIN (tmp) && TREE_CODE (TREE_CHAIN (tmp)) == TREE_LIST)
- {
- pp_character (buffer, ',');
- pp_space (buffer);
- }
- }
- }
- pp_character (buffer, ')');
+ dump_function_declaration (buffer, fnode, spc, flags);
}
else
{
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, "::");
break;
- case FILE_TYPE:
- NIY;
+ case TARGET_MEM_REF:
+ {
+ const char *sep = "";
+ tree tmp;
+
+ pp_string (buffer, "MEM[");
+
+ tmp = TMR_SYMBOL (node);
+ if (tmp)
+ {
+ pp_string (buffer, sep);
+ sep = ", ";
+ pp_string (buffer, "symbol: ");
+ dump_generic_node (buffer, tmp, spc, flags, false);
+ }
+ tmp = TMR_BASE (node);
+ if (tmp)
+ {
+ pp_string (buffer, sep);
+ sep = ", ";
+ pp_string (buffer, "base: ");
+ dump_generic_node (buffer, tmp, spc, flags, false);
+ }
+ tmp = TMR_INDEX (node);
+ if (tmp)
+ {
+ pp_string (buffer, sep);
+ sep = ", ";
+ pp_string (buffer, "index: ");
+ dump_generic_node (buffer, tmp, spc, flags, false);
+ }
+ tmp = TMR_STEP (node);
+ if (tmp)
+ {
+ pp_string (buffer, sep);
+ sep = ", ";
+ pp_string (buffer, "step: ");
+ dump_generic_node (buffer, tmp, spc, flags, false);
+ }
+ tmp = TMR_OFFSET (node);
+ if (tmp)
+ {
+ pp_string (buffer, sep);
+ sep = ", ";
+ pp_string (buffer, "offset: ");
+ dump_generic_node (buffer, tmp, spc, flags, false);
+ }
+ pp_string (buffer, "]");
+ if (flags & TDF_DETAILS)
+ {
+ pp_string (buffer, "{");
+ dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
+ false);
+ pp_string (buffer, "}");
+ }
+ }
break;
case ARRAY_TYPE:
{
tree tmp;
- /* Print the array type. */
- dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
+ /* Print the innermost component type. */
+ for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
+ tmp = TREE_TYPE (tmp))
+ ;
+ dump_generic_node (buffer, tmp, spc, flags, false);
/* Print the dimensions. */
- tmp = node;
- while (tmp && TREE_CODE (tmp) == ARRAY_TYPE)
- {
- pp_character (buffer, '[');
- if (TYPE_SIZE (tmp))
- {
- tree size = TYPE_SIZE (tmp);
- if (TREE_CODE (size) == INTEGER_CST)
- pp_wide_integer (buffer,
- TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
- TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
- else if (TREE_CODE (size) == MULT_EXPR)
- dump_generic_node (buffer, TREE_OPERAND (size, 0), spc, flags, false);
- /* else punt. */
- }
- pp_character (buffer, ']');
- tmp = TREE_TYPE (tmp);
- }
+ for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
+ dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
break;
}
- case SET_TYPE:
- NIY;
- break;
-
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 ");
print_struct_decl (buffer, node, spc, flags);
break;
- case QUAL_UNION_TYPE:
- NIY;
- break;
-
-
case LANG_TYPE:
NIY;
break;
if (tree_int_cst_sgn (val) < 0)
{
pp_character (buffer, '-');
- val = build_int_2 (-TREE_INT_CST_LOW (val),
- ~TREE_INT_CST_HIGH (val)
- + !TREE_INT_CST_LOW (val));
+ val = build_int_cst_wide (NULL_TREE,
+ -TREE_INT_CST_LOW (val),
+ ~TREE_INT_CST_HIGH (val)
+ + !TREE_INT_CST_LOW (val));
}
/* Would "%x%0*x" or "%x%*0x" get zero-padding on all
systems? */
break;
case TYPE_DECL:
- if (strcmp (DECL_SOURCE_FILE (node), "<built-in>") == 0)
+ if (DECL_IS_BUILTIN (node))
{
/* Don't print the declaration of built-in types. */
break;
}
if (DECL_NAME (node))
- {
- dump_decl_name (buffer, node, flags);
- }
+ dump_decl_name (buffer, node, flags);
else
{
- if (TYPE_METHODS (TREE_TYPE (node)))
+ if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
+ || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
+ && TYPE_METHODS (TREE_TYPE (node)))
{
/* The type is a c++ class: all structures have at least
4 methods. */
}
else
{
- pp_string (buffer, "struct ");
+ pp_string (buffer,
+ (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
+ ? "union" : "struct "));
dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
- pp_character (buffer, ';');
- pp_newline (buffer);
}
}
break;
+ 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)
+ {
+ pp_string (buffer, "{off: ");
+ dump_generic_node (buffer, op0, spc, flags, false);
+ pp_character (buffer, '}');
+ }
+ }
break;
case BIT_FIELD_REF:
pp_string (buffer, ">");
break;
- case BUFFER_REF:
- NIY;
- break;
-
case ARRAY_REF:
+ case ARRAY_RANGE_REF:
op0 = TREE_OPERAND (node, 0);
if (op_prio (op0) < op_prio (node))
pp_character (buffer, '(');
pp_character (buffer, ')');
pp_character (buffer, '[');
dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ if (TREE_CODE (node) == ARRAY_RANGE_REF)
+ pp_string (buffer, " ...");
pp_character (buffer, ']');
- break;
- case ARRAY_RANGE_REF:
- NIY;
+ op0 = array_ref_low_bound (node);
+ op1 = array_ref_element_size (node);
+
+ if (!integer_zerop (op0)
+ || (TYPE_SIZE_UNIT (TREE_TYPE (node))
+ && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
+ {
+ pp_string (buffer, "{lb: ");
+ dump_generic_node (buffer, op0, spc, flags, false);
+ pp_string (buffer, " sz: ");
+ dump_generic_node (buffer, op1, spc, flags, false);
+ pp_character (buffer, '}');
+ }
break;
case CONSTRUCTOR:
{
- tree lnode;
+ unsigned HOST_WIDE_INT ix;
+ tree field, val;
bool is_struct_init = FALSE;
pp_character (buffer, '{');
- lnode = CONSTRUCTOR_ELTS (node);
if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
|| TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
is_struct_init = TRUE;
- while (lnode && lnode != error_mark_node)
+ FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
{
- tree val;
- if (TREE_PURPOSE (lnode) && is_struct_init)
+ if (field && is_struct_init)
{
pp_character (buffer, '.');
- dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false);
+ dump_generic_node (buffer, field, spc, flags, false);
pp_string (buffer, "=");
}
- val = TREE_VALUE (lnode);
if (val && TREE_CODE (val) == ADDR_EXPR)
if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
val = TREE_OPERAND (val, 0);
if (val && TREE_CODE (val) == FUNCTION_DECL)
- {
dump_decl_name (buffer, val, flags);
- }
else
- {
- dump_generic_node (buffer, TREE_VALUE (lnode), spc, flags, false);
- }
- lnode = TREE_CHAIN (lnode);
- if (lnode && TREE_CODE (lnode) == TREE_LIST)
+ dump_generic_node (buffer, val, spc, flags, false);
+ if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
{
pp_character (buffer, ',');
pp_space (buffer);
}
dump_generic_node (buffer, TREE_OPERAND (node, 0),
- spc, flags, dumping_stmts);
- if (dumping_stmts)
+ spc, flags, !(flags & TDF_SLIM));
+ if (flags & TDF_SLIM)
newline_and_indent (buffer, spc);
else
{
tp = &TREE_OPERAND (*tp, 1))
{
dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
- spc, flags, dumping_stmts);
- if (dumping_stmts)
+ spc, flags, !(flags & TDF_SLIM));
+ if (flags & TDF_SLIM)
newline_and_indent (buffer, spc);
else
{
}
}
- dump_generic_node (buffer, *tp, spc, flags, dumping_stmts);
+ dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
}
break;
{
tree_stmt_iterator si;
bool first = true;
-
- if ((flags & TDF_SLIM) || !dumping_stmts)
+
+ if (flags & TDF_SLIM)
{
pp_string (buffer, "<STATEMENT_LIST>");
break;
break;
case TARGET_EXPR:
- dump_generic_node (buffer, TYPE_NAME (TREE_TYPE (node)), spc, flags, false);
- pp_character (buffer, '(');
+ pp_string (buffer, "TARGET_EXPR <");
+ dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
+ pp_character (buffer, ',');
+ pp_space (buffer);
dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
- pp_character (buffer, ')');
+ pp_character (buffer, '>');
+ break;
+
+ case DECL_EXPR:
+ print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
+ is_stmt = false;
break;
case COND_EXPR:
- if (TREE_TYPE (node) == void_type_node)
+ if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
{
pp_string (buffer, "if (");
dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
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);
pp_character (buffer, ']');
}
+ if (CALL_EXPR_RETURN_SLOT_OPT (node))
+ pp_string (buffer, " [return slot optimization]");
if (CALL_EXPR_TAILCALL (node))
pp_string (buffer, " [tail call]");
break;
break;
case PLACEHOLDER_EXPR:
- NIY;
+ pp_string (buffer, "<PLACEHOLDER_EXPR ");
+ dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
+ pp_character (buffer, '>');
break;
/* Binary arithmetic and logic expressions. */
+ case WIDEN_SUM_EXPR:
+ case WIDEN_MULT_EXPR:
case MULT_EXPR:
case PLUS_EXPR:
case MINUS_EXPR:
case RSHIFT_EXPR:
case LROTATE_EXPR:
case RROTATE_EXPR:
+ case VEC_LSHIFT_EXPR:
+ case VEC_RSHIFT_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case BIT_AND_EXPR:
case BIT_NOT_EXPR:
case TRUTH_NOT_EXPR:
case ADDR_EXPR:
- case REFERENCE_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, '>');
break;
- case IN_EXPR:
- NIY;
- break;
-
- case SET_LE_EXPR:
- NIY;
- break;
-
- case CARD_EXPR:
- NIY;
- break;
-
case RANGE_EXPR:
NIY;
break;
{
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_character (buffer, '>');
break;
- case UNSAVE_EXPR:
- pp_string (buffer, "UNSAVE_EXPR <");
- dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
- pp_character (buffer, '>');
- break;
-
- case RTL_EXPR:
- NIY;
- break;
-
- case ENTRY_VALUE_EXPR:
- NIY;
- break;
-
case COMPLEX_EXPR:
pp_string (buffer, "COMPLEX_EXPR <");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
is_expr = false;
break;
- case GOTO_SUBROUTINE_EXPR:
- NIY;
- break;
-
case LABEL_EXPR:
op0 = TREE_OPERAND (node, 0);
/* If this is for break or continue, don't bother printing it. */
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;
if (SWITCH_BODY (node))
{
newline_and_indent (buffer, spc+4);
- dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
+ dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
+ true);
}
else
{
{
tree elt = TREE_VEC_ELT (vec, i);
newline_and_indent (buffer, spc+4);
- dump_generic_node (buffer, elt, spc+4, flags, false);
- pp_string (buffer, " goto ");
- dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
- pp_semicolon (buffer);
+ if (elt)
+ {
+ dump_generic_node (buffer, elt, spc+4, flags, false);
+ pp_string (buffer, " goto ");
+ dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
+ flags, true);
+ pp_semicolon (buffer);
+ }
+ else
+ pp_string (buffer, "case ???: goto ???;");
}
}
newline_and_indent (buffer, spc+2);
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
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:
pp_character (buffer, ':');
break;
- case VTABLE_REF:
- pp_string (buffer, "VTABLE_REF <(");
- 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_character (buffer, ',');
- dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
+ case OBJ_TYPE_REF:
+ pp_string (buffer, "OBJ_TYPE_REF(");
+ dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
+ pp_character (buffer, ';');
+ dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
+ pp_character (buffer, '-');
pp_character (buffer, '>');
+ dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
+ pp_character (buffer, ')');
break;
- case EPHI_NODE:
- {
- int i;
-
- pp_string (buffer, " EPHI (");
- dump_generic_node (buffer, EREF_NAME (node), spc, flags, false);
- pp_string (buffer, ") ");
- pp_character (buffer, '[');
- pp_string (buffer, " class:");
- pp_decimal_int (buffer, EREF_CLASS (node));
- if (EPHI_DOWNSAFE (node))
- pp_string (buffer, " downsafe");
- if (EPHI_CANT_BE_AVAIL (node))
- pp_string (buffer, " cant_be_avail");
- if (EPHI_STOPS (node))
- pp_string (buffer, " stops");
- pp_string (buffer, " bb:");
- pp_decimal_int (buffer, bb_for_stmt (node)->index);
- pp_character (buffer, ']');
- if (! (flags & TDF_SLIM))
- {
- pp_string (buffer, " <");
- for (i = 0; i < EPHI_NUM_ARGS (node); i++)
- {
- if (EPHI_ARG_DEF (node, i))
- {
- newline_and_indent (buffer, spc + 2);
- pp_string (buffer, " edge ");
- pp_decimal_int (buffer, EPHI_ARG_EDGE (node, i)->src->index);
- pp_string (buffer, "->");
- pp_decimal_int (buffer, EPHI_ARG_EDGE (node, i)->dest->index);
- pp_string (buffer, " [ ");
- if (EPHI_ARG_HAS_REAL_USE (node, i))
- pp_string (buffer, " real use");
- if (EPHI_ARG_INJURED (node, i))
- pp_string (buffer, " injured");
- if (EPHI_ARG_STOPS (node, i))
- pp_string (buffer, " stops");
- pp_string (buffer, " ] ");
- pp_string (buffer, " defined by:");
- dump_generic_node (buffer, EPHI_ARG_DEF (node, i),
- spc + 4, flags | TDF_SLIM, false);
- }
- }
- }
- pp_string (buffer, " >");
- }
- break;
- case EEXIT_NODE:
- case EKILL_NODE:
- if (TREE_CODE (node) == EEXIT_NODE)
- pp_string (buffer, "EEXIT (");
- else if (TREE_CODE (node) == EKILL_NODE)
- pp_string (buffer, "EKILL (");
- dump_generic_node (buffer, EREF_NAME (node), spc, flags, false);
- pp_string (buffer, ") ");
- pp_character (buffer, '[');
- pp_string (buffer, "class:");
- pp_decimal_int (buffer, EREF_CLASS (node));
- pp_string (buffer, " bb:");
- pp_decimal_int (buffer, bb_for_stmt (node)->index);
- pp_character (buffer, ']');
- break;
- case EUSE_NODE:
- pp_string (buffer, " EUSE (");
- dump_generic_node (buffer, EREF_NAME (node), spc, flags, false);
-
- pp_string (buffer, ") ");
- pp_character (buffer, '[');
- pp_string (buffer, "class:");
- pp_decimal_int (buffer, EREF_CLASS (node));
- pp_string (buffer, " phiop:");
- pp_decimal_int (buffer, EUSE_PHIOP (node));
- pp_string (buffer, " bb:");
- pp_decimal_int (buffer, bb_for_stmt (node)->index);
- if (EUSE_LVAL (node))
- pp_string (buffer, " left-occurrence");
- pp_string (buffer, " ]");
-
- break;
case PHI_NODE:
{
int i;
dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
pp_string (buffer, "_");
pp_decimal_int (buffer, SSA_NAME_VERSION (node));
+ if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
+ pp_string (buffer, "(ab)");
+ break;
+
+ case WITH_SIZE_EXPR:
+ pp_string (buffer, "WITH_SIZE_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 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);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
+ pp_string (buffer, ">");
+ break;
+
+ case SCEV_KNOWN:
+ pp_string (buffer, "scev_known");
+ break;
+
+ case SCEV_NOT_KNOWN:
+ pp_string (buffer, "scev_not_known");
+ break;
+
+ case POLYNOMIAL_CHREC:
+ pp_string (buffer, "{");
+ dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
+ pp_string (buffer, ", +, ");
+ dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
+ pp_string (buffer, "}_");
+ dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
+ 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;
+
+ 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))
+ {
+ newline_and_indent (buffer, spc + 2);
+ pp_character (buffer, '{');
+ newline_and_indent (buffer, spc + 4);
+ dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
+ newline_and_indent (buffer, spc + 2);
+ pp_character (buffer, '}');
+ }
+ is_expr = false;
+ break;
+
+ case OMP_FOR:
+ pp_string (buffer, "#pragma omp for");
+ dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
+
+ if (!(flags & TDF_SLIM))
+ {
+ if (OMP_FOR_PRE_BODY (node))
+ {
+ newline_and_indent (buffer, spc + 2);
+ pp_character (buffer, '{');
+ spc += 4;
+ newline_and_indent (buffer, spc);
+ 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, ")");
+ if (OMP_FOR_BODY (node))
+ {
+ newline_and_indent (buffer, spc + 2);
+ pp_character (buffer, '{');
+ newline_and_indent (buffer, spc + 4);
+ dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
+ false);
+ newline_and_indent (buffer, spc + 2);
+ pp_character (buffer, '}');
+ }
+ if (OMP_FOR_PRE_BODY (node))
+ {
+ spc -= 4;
+ newline_and_indent (buffer, spc + 2);
+ pp_character (buffer, '}');
+ }
+ }
+ is_expr = false;
+ break;
+
+ case OMP_SECTIONS:
+ pp_string (buffer, "#pragma omp sections");
+ dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
+ goto dump_omp_body;
+
+ 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;
+
+ case OMP_ORDERED:
+ pp_string (buffer, "#pragma omp ordered");
+ goto dump_omp_body;
+
+ case OMP_CRITICAL:
+ pp_string (buffer, "#pragma omp critical");
+ if (OMP_CRITICAL_NAME (node))
+ {
+ pp_space (buffer);
+ pp_character (buffer, '(');
+ dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
+ flags, false);
+ pp_character (buffer, ')');
+ }
+ goto dump_omp_body;
+
+ case OMP_ATOMIC:
+ pp_string (buffer, "#pragma omp atomic");
+ 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);
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ break;
+
+ case OMP_SINGLE:
+ pp_string (buffer, "#pragma omp single");
+ 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 REDUC_MIN_EXPR:
+ pp_string (buffer, " REDUC_MIN_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
+ case REDUC_PLUS_EXPR:
+ pp_string (buffer, " REDUC_PLUS_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, " > ");
break;
+ case BLOCK:
+ {
+ tree t;
+ pp_string (buffer, "BLOCK");
+
+ if (BLOCK_ABSTRACT (node))
+ pp_string (buffer, " [abstract]");
+
+ if (TREE_ASM_WRITTEN (node))
+ pp_string (buffer, " [written]");
+
+ newline_and_indent (buffer, spc + 2);
+
+ if (BLOCK_SUPERCONTEXT (node))
+ {
+ pp_string (buffer, "SUPERCONTEXT: ");
+ if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
+ pp_printf (buffer, "BLOCK %p",
+ (void *)BLOCK_SUPERCONTEXT (node));
+ else
+ dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
+ false);
+ newline_and_indent (buffer, spc + 2);
+ }
+
+ if (BLOCK_SUBBLOCKS (node))
+ {
+ pp_string (buffer, "SUBBLOCKS: ");
+ for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
+ pp_printf (buffer, "%p ", (void *)t);
+ newline_and_indent (buffer, spc + 2);
+ }
+
+ if (BLOCK_VARS (node))
+ {
+ pp_string (buffer, "VARS: ");
+ for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
+ {
+ dump_generic_node (buffer, t, 0, flags, false);
+ pp_string (buffer, " ");
+ }
+ newline_and_indent (buffer, spc + 2);
+ }
+
+ if (BLOCK_ABSTRACT_ORIGIN (node))
+ {
+ pp_string (buffer, "ABSTRACT_ORIGIN: ");
+ if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
+ pp_printf (buffer, "BLOCK %p",
+ (void *)BLOCK_ABSTRACT_ORIGIN (node));
+ else
+ dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
+ false);
+ newline_and_indent (buffer, spc + 2);
+ }
+ }
+ break;
+
default:
NIY;
}
static void
print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
{
- /* Don't print type declarations. */
- if (TREE_CODE (t) == TYPE_DECL)
- return;
-
INDENT (spc);
- if (DECL_REGISTER (t))
+ if (TREE_CODE (t) == TYPE_DECL)
+ pp_string (buffer, "typedef ");
+
+ if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
pp_string (buffer, "register ");
if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
tmp = TREE_TYPE (t);
while (TREE_CODE (tmp) == ARRAY_TYPE)
{
- 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);
- }
- pp_character (buffer, ']');
+ dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
tmp = TREE_TYPE (tmp);
}
}
+ else if (TREE_CODE (t) == FUNCTION_DECL)
+ {
+ dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
+ pp_space (buffer);
+ dump_decl_name (buffer, t, flags);
+ dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
+ }
else
{
/* Print type declaration. */
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. */
}
}
+ if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
+ {
+ pp_string (buffer, " [value-expr: ");
+ dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
+ pp_character (buffer, ']');
+ }
+
pp_character (buffer, ';');
}
INDENT (spc);
if (TREE_CODE (node) == RECORD_TYPE)
pp_string (buffer, "struct ");
- else if (TREE_CODE (node) == UNION_TYPE)
+ else if ((TREE_CODE (node) == UNION_TYPE
+ || TREE_CODE (node) == QUAL_UNION_TYPE))
pp_string (buffer, "union ");
- else
- NIY;
+
dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
}
Maybe this could be solved by looking at the scope in which the
structure was declared. */
if (TREE_TYPE (tmp) != node
- || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE &&
- TREE_TYPE (TREE_TYPE (tmp)) != node))
+ || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
+ && TREE_TYPE (TREE_TYPE (tmp)) != node))
{
print_declaration (buffer, tmp, spc+2, flags);
pp_newline (buffer);
}
- else
- {
-
- }
tmp = TREE_CHAIN (tmp);
}
}
case RROTATE_EXPR:
return 11;
+ case WIDEN_SUM_EXPR:
case PLUS_EXPR:
case MINUS_EXPR:
return 12;
+ case WIDEN_MULT_EXPR:
+ case DOT_PROD_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 FLOAT_EXPR:
case CALL_EXPR:
case ARRAY_REF:
+ case ARRAY_RANGE_REF:
case COMPONENT_REF:
return 15;
case ABS_EXPR:
case REALPART_EXPR:
case IMAGPART_EXPR:
+ case REDUC_MAX_EXPR:
+ case REDUC_MIN_EXPR:
+ case REDUC_PLUS_EXPR:
+ case VEC_LSHIFT_EXPR:
+ case VEC_RSHIFT_EXPR:
return 16;
case SAVE_EXPR:
/* Return the symbol associated with operator OP. */
static const char *
-op_symbol (tree op)
+op_symbol_1 (enum tree_code code)
{
- if (op == NULL)
- abort ();
-
- switch (TREE_CODE (op))
+ switch (code)
{
case MODIFY_EXPR:
return "=";
case RSHIFT_EXPR:
return ">>";
+ case LROTATE_EXPR:
+ return "r<<";
+
+ case RROTATE_EXPR:
+ return "r>>";
+
+ case VEC_LSHIFT_EXPR:
+ return "v<<";
+
+ case VEC_RSHIFT_EXPR:
+ return "v>>";
+
case PLUS_EXPR:
return "+";
+ 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 "-";
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 " --";
case POSTINCREMENT_EXPR:
return "++ ";
- case REFERENCE_EXPR:
- return "";
+ case MAX_EXPR:
+ return "max";
+
+ case MIN_EXPR:
+ return "min";
default:
return "<<< ??? >>>";
}
}
+static const char *
+op_symbol (tree op)
+{
+ return op_symbol_1 (TREE_CODE (op));
+}
+
/* Prints the name of a CALL_EXPR. */
static void
{
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;
case SSA_NAME:
+ case OBJ_TYPE_REF:
dump_generic_node (buffer, op0, 0, 0, false);
break;
static void
dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
{
- size_t i;
- stmt_ann_t ann = stmt_ann (stmt);
- v_may_def_optype v_may_defs = V_MAY_DEF_OPS (ann);
- v_must_def_optype v_must_defs = V_MUST_DEF_OPS (ann);
- vuse_optype vuses = VUSE_OPS (ann);
+ tree use;
+ use_operand_p use_p;
+ def_operand_p def_p;
+ use_operand_p kill_p;
+ ssa_op_iter iter;
+
+ if (!ssa_operands_active ())
+ return;
- for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
+ FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
{
pp_string (buffer, "# ");
- dump_generic_node (buffer, V_MAY_DEF_RESULT (v_may_defs, i),
+ dump_generic_node (buffer, DEF_FROM_PTR (def_p),
spc + 2, flags, false);
pp_string (buffer, " = V_MAY_DEF <");
- dump_generic_node (buffer, V_MAY_DEF_OP (v_may_defs, i),
+ dump_generic_node (buffer, USE_FROM_PTR (use_p),
spc + 2, flags, false);
pp_string (buffer, ">;");
newline_and_indent (buffer, spc);
}
- for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
+ FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
{
- tree v_must_def = V_MUST_DEF_OP (v_must_defs, i);
- pp_string (buffer, "# V_MUST_DEF <");
- dump_generic_node (buffer, v_must_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);
}
- for (i = 0; i < NUM_VUSES (vuses); i++)
+ FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
{
- tree vuse = VUSE_OP (vuses, i);
pp_string (buffer, "# VUSE <");
- dump_generic_node (buffer, vuse, spc + 2, flags, false);
+ dump_generic_node (buffer, use, spc + 2, flags, false);
pp_string (buffer, ">;");
newline_and_indent (buffer, spc);
}
dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
{
maybe_init_pretty_print (file);
- dumping_stmts = true;
dump_generic_bb_buff (&buffer, bb, indent, flags);
pp_flush (&buffer);
}
{
edge e;
tree stmt;
+ edge_iterator ei;
if (flags & TDF_BLOCKS)
{
INDENT (indent);
pp_string (buffer, "# BLOCK ");
pp_decimal_int (buffer, bb->index);
+ if (bb->frequency)
+ {
+ pp_string (buffer, " freq:");
+ pp_decimal_int (buffer, bb->frequency);
+ }
+ if (bb->count)
+ {
+ pp_string (buffer, " count:");
+ pp_widest_integer (buffer, bb->count);
+ }
if (flags & TDF_LINENO)
{
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)
pp_newline (buffer);
}
}
+ pp_write_text_to_stream (buffer);
+ check_bb_profile (bb, buffer->buffer->stream);
}
/* Dumps end of basic block BB to buffer BUFFER indented by INDENT
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, " ");
if (!phi)
return;
- for (; phi; phi = TREE_CHAIN (phi))
+ for (; phi; phi = PHI_CHAIN (phi))
{
if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
{
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)
{
INDENT (indent);
- if ((flags & TDF_LINENO) && e->goto_locus)
+ if ((flags & TDF_LINENO)
+#ifdef USE_MAPPED_LOCATION
+ && e->goto_locus != UNKNOWN_LOCATION
+#else
+ && e->goto_locus
+#endif
+ )
{
+ 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 (e->goto_locus->file)
+ if (goto_xloc.file)
{
- pp_string (buffer, e->goto_locus->file);
+ pp_string (buffer, goto_xloc.file);
pp_string (buffer, " : ");
}
- pp_decimal_int (buffer, e->goto_locus->line);
+ pp_decimal_int (buffer, goto_xloc.line);
pp_string (buffer, "] ");
}
dump_bb_header (buffer, bb, indent, flags);
- if (bb_ann (bb))
- dump_phi_nodes (buffer, bb, indent, flags);
-
+ dump_phi_nodes (buffer, bb, indent, flags);
+
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
int curr_indent;
OSDN Git Service
