/* Pretty formatting of GENERIC trees in C syntax.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
- Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+ 2011 Free Software Foundation, Inc.
Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
pp_character (buffer, ')');
break;
+ case OMP_CLAUSE_FINAL:
+ pp_string (buffer, "final(");
+ dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause),
+ spc, flags, false);
+ pp_character (buffer, ')');
+ break;
+
+ case OMP_CLAUSE_MERGEABLE:
+ pp_string (buffer, "mergeable");
+ break;
+
default:
/* Should never happen. */
dump_generic_node (buffer, clause, spc, flags, false);
infer them and MEM_ATTR caching will share MEM_REFs
with differently-typed op0s. */
&& TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
+ /* Released SSA_NAMES have no TREE_TYPE. */
+ && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
/* Same pointer types, but ignoring POINTER_TYPE vs.
REFERENCE_TYPE. */
&& (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
pp_string (buffer, "B"); /* pseudo-unit */
}
- else if (! host_integerp (node, 0))
+ else if (host_integerp (node, 0))
+ pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
+ else if (host_integerp (node, 1))
+ pp_unsigned_wide_integer (buffer, TREE_INT_CST_LOW (node));
+ else
{
tree val = node;
unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
(unsigned HOST_WIDE_INT) high, low);
pp_string (buffer, pp_buffer (buffer)->digit_buffer);
}
- else
- pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
break;
case REAL_CST:
can't infer them and MEM_ATTR caching will share
MEM_REFs with differently-typed op0s. */
&& TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
+ /* Released SSA_NAMES have no TREE_TYPE. */
+ && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
/* Same pointer types, but ignoring POINTER_TYPE vs.
REFERENCE_TYPE. */
&& (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
{
unsigned HOST_WIDE_INT ix;
tree field, val;
- bool is_struct_init = FALSE;
+ bool is_struct_init = false;
+ bool is_array_init = false;
+ double_int curidx = double_int_zero;
pp_character (buffer, '{');
- if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
- || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
- is_struct_init = TRUE;
+ if (TREE_CLOBBER_P (node))
+ pp_string (buffer, "CLOBBER");
+ else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
+ || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
+ is_struct_init = true;
+ else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
+ && TYPE_DOMAIN (TREE_TYPE (node))
+ && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
+ && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
+ == INTEGER_CST)
+ {
+ tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
+ is_array_init = true;
+ curidx = tree_to_double_int (minv);
+ }
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
{
- if (field && is_struct_init)
+ if (field)
{
- pp_character (buffer, '.');
- dump_generic_node (buffer, field, spc, flags, false);
- pp_string (buffer, "=");
+ if (is_struct_init)
+ {
+ pp_character (buffer, '.');
+ dump_generic_node (buffer, field, spc, flags, false);
+ pp_character (buffer, '=');
+ }
+ else if (is_array_init
+ && (TREE_CODE (field) != INTEGER_CST
+ || !double_int_equal_p (tree_to_double_int (field),
+ curidx)))
+ {
+ pp_character (buffer, '[');
+ if (TREE_CODE (field) == RANGE_EXPR)
+ {
+ dump_generic_node (buffer, TREE_OPERAND (field, 0), spc,
+ flags, false);
+ pp_string (buffer, " ... ");
+ dump_generic_node (buffer, TREE_OPERAND (field, 1), spc,
+ flags, false);
+ if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
+ curidx = tree_to_double_int (TREE_OPERAND (field, 1));
+ }
+ else
+ dump_generic_node (buffer, field, spc, flags, false);
+ if (TREE_CODE (field) == INTEGER_CST)
+ curidx = tree_to_double_int (field);
+ pp_string (buffer, "]=");
+ }
}
+ if (is_array_init)
+ curidx = double_int_add (curidx, double_int_one);
if (val && TREE_CODE (val) == ADDR_EXPR)
if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
val = TREE_OPERAND (val, 0);
case RROTATE_EXPR:
case VEC_LSHIFT_EXPR:
case VEC_RSHIFT_EXPR:
+ case WIDEN_LSHIFT_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case BIT_AND_EXPR:
dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
pp_string (buffer, " > ");
break;
+
+ case VEC_PERM_EXPR:
+ pp_string (buffer, " VEC_PERM_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, 1), spc, flags, false);
break;
+ case OMP_ATOMIC_READ:
+ pp_string (buffer, "#pragma omp atomic read");
+ newline_and_indent (buffer, spc + 2);
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_space (buffer);
+ break;
+
+ case OMP_ATOMIC_CAPTURE_OLD:
+ case OMP_ATOMIC_CAPTURE_NEW:
+ pp_string (buffer, "#pragma omp atomic capture");
+ 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);
is_expr = false;
break;
+ case TRANSACTION_EXPR:
+ if (TRANSACTION_EXPR_OUTER (node))
+ pp_string (buffer, "__transaction_atomic [[outer]]");
+ else if (TRANSACTION_EXPR_RELAXED (node))
+ pp_string (buffer, "__transaction_relaxed");
+ else
+ pp_string (buffer, "__transaction_atomic");
+ if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
+ {
+ newline_and_indent (buffer, spc);
+ pp_character (buffer, '{');
+ newline_and_indent (buffer, spc + 2);
+ dump_generic_node (buffer, TRANSACTION_EXPR_BODY (node),
+ spc + 2, flags, false);
+ newline_and_indent (buffer, spc);
+ pp_character (buffer, '}');
+ }
+ 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_LSHIFT_HI_EXPR:
+ pp_string (buffer, " VEC_WIDEN_LSHIFT_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_LSHIFT_LO_EXPR:
+ pp_string (buffer, " VEC_WIDEN_LSHIFT_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_UNPACK_HI_EXPR:
pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
dump_block_node (buffer, node, spc, flags);
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;
}
case RSHIFT_EXPR:
case LROTATE_EXPR:
case RROTATE_EXPR:
+ case VEC_WIDEN_LSHIFT_HI_EXPR:
+ case VEC_WIDEN_LSHIFT_LO_EXPR:
+ case WIDEN_LSHIFT_EXPR:
return 11;
case WIDEN_SUM_EXPR:
case VEC_RSHIFT_EXPR:
return "v>>";
+ case WIDEN_LSHIFT_EXPR:
+ return "w<<";
+
case POINTER_PLUS_EXPR:
return "+";
pp_append_text (pp, IDENTIFIER_POINTER (id),
IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
}
+
+/* A helper function that is used to dump function information before the
+ function dump. */
+
+void
+dump_function_header (FILE *dump_file, tree fdecl, int flags)
+{
+ const char *dname, *aname;
+ struct cgraph_node *node = cgraph_get_node (fdecl);
+ struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
+
+ dname = lang_hooks.decl_printable_name (fdecl, 2);
+
+ if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
+ aname = (IDENTIFIER_POINTER
+ (DECL_ASSEMBLER_NAME (fdecl)));
+ else
+ aname = "<unset-asm-name>";
+
+ fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
+ dname, aname, fun->funcdef_no);
+ if (!(flags & TDF_NOUID))
+ fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
+ if (node)
+ {
+ fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid,
+ node->frequency == NODE_FREQUENCY_HOT
+ ? " (hot)"
+ : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
+ ? " (unlikely executed)"
+ : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
+ ? " (executed once)"
+ : "");
+ }
+ else
+ fprintf (dump_file, ")\n\n");
+}
OSDN Git Service
