/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005 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 "langhooks.h"
#include "tree-iterator.h"
#include "tree-chrec.h"
+#include "tree-pass.h"
/* Local functions, macros and variables. */
static int op_prio (tree);
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
+ {
+ 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 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 (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 (is_stmt && (flags & TDF_STMTADDR))
+ pp_printf (buffer, "<&%p> ", (void *)node);
+
if (dumping_stmts
&& (flags & TDF_LINENO)
&& EXPR_HAS_LOCATION (node))
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:
dump_generic_node (buffer, tmp, spc, flags, false);
/* Print the dimensions. */
- for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE;
- tmp = TREE_TYPE (tmp))
- {
- tree domain = TYPE_DOMAIN (tmp);
-
- pp_character (buffer, '[');
- if (domain)
- {
- if (TYPE_MIN_VALUE (domain)
- && !integer_zerop (TYPE_MIN_VALUE (domain)))
- {
- dump_generic_node (buffer, TYPE_MIN_VALUE (domain),
- spc, flags, false);
- pp_string (buffer, " .. ");
- }
-
- if (TYPE_MAX_VALUE (domain))
- dump_generic_node (buffer, TYPE_MAX_VALUE (domain),
- spc, flags, false);
- }
- else
- pp_string (buffer, "<unknown>");
-
- pp_character (buffer, ']');
- }
+ 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:
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);
pp_character (buffer, ']');
}
- if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (node))
- pp_string (buffer, " [return slot addr]");
+ if (CALL_EXPR_RETURN_SLOT_OPT (node))
+ pp_string (buffer, " [return slot optimization]");
if (CALL_EXPR_TAILCALL (node))
pp_string (buffer, " [tail call]");
break;
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:
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_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;
pp_string (buffer, " > ");
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;
+
default:
NIY;
}
if (TREE_CODE (t) == TYPE_DECL)
pp_string (buffer, "typedef ");
- if (DECL_REGISTER (t))
+ 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 (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, ']');
+ dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
tmp = TREE_TYPE (tmp);
}
}
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:
case RSHIFT_EXPR:
return ">>";
+ case VEC_LSHIFT_EXPR:
+ return "v<<";
+
+ case VEC_RSHIFT_EXPR:
+ return "v>>";
+
case PLUS_EXPR:
return "+";
+ case REDUC_PLUS_EXPR:
+ return "r+";
+
case NEGATE_EXPR:
case MINUS_EXPR:
return "-";
use_operand_p kill_p;
ssa_op_iter iter;
+ if (!ssa_operands_active ())
+ return;
+
FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
{
pp_string (buffer, "# ");
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)
{
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))
{