/* Tree-dumping functionality for intermediate representation.
- Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005
+ Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
Written by Mark Mitchell <mark@codesourcery.com>
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
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, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "tree-pass.h"
#include "langhooks.h"
#include "tree-iterator.h"
+#include "real.h"
+#include "fixed-value.h"
-static unsigned int queue (dump_info_p, tree, int);
+static unsigned int queue (dump_info_p, const_tree, int);
static void dump_index (dump_info_p, unsigned int);
static void dequeue_and_dump (dump_info_p);
static void dump_new_line (dump_info_p);
assigned to T. */
static unsigned int
-queue (dump_info_p di, tree t, int flags)
+queue (dump_info_p di, const_tree t, int flags)
{
dump_queue_p dq;
dump_node_info_p dni;
di->free_list = dq->next;
}
else
- dq = xmalloc (sizeof (struct dump_queue));
+ dq = XNEW (struct dump_queue);
/* Create a new entry in the splay-tree. */
- dni = xmalloc (sizeof (struct dump_node_info));
+ dni = XNEW (struct dump_node_info);
dni->index = index;
dni->binfo_p = ((flags & DUMP_BINFO) != 0);
dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t,
index of T is printed. */
void
-queue_and_dump_index (dump_info_p di, const char *field, tree t, int flags)
+queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags)
{
unsigned int index;
splay_tree_node n;
/* Dump the type of T. */
void
-queue_and_dump_type (dump_info_p di, tree t)
+queue_and_dump_type (dump_info_p di, const_tree t)
{
queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
}
dump_pointer (dump_info_p di, const char *field, void *ptr)
{
dump_maybe_newline (di);
- fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
+ fprintf (di->stream, "%-4s: %-8lx ", field, (unsigned long) ptr);
di->column += 15;
}
di->column += 14;
}
+/* Dump the floating point value R, using FIELD to identify it. */
+
+static void
+dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r)
+{
+ char buf[32];
+ real_to_decimal (buf, r, sizeof (buf), 0, true);
+ dump_maybe_newline (di);
+ fprintf (di->stream, "%-4s: %s ", field, buf);
+ di->column += strlen (buf) + 7;
+}
+
+/* Dump the fixed-point value F, using FIELD to identify it. */
+
+static void
+dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f)
+{
+ char buf[32];
+ fixed_to_decimal (buf, f, sizeof (buf));
+ dump_maybe_newline (di);
+ fprintf (di->stream, "%-4s: %s ", field, buf);
+ di->column += strlen (buf) + 7;
+}
+
+
/* Dump the string S. */
void
case tcc_expression:
case tcc_reference:
case tcc_statement:
+ case tcc_vl_exp:
/* These nodes are handled explicitly below. */
break;
di->column += 6 + strlen (filename) + 8;
}
/* And any declaration can be compiler-generated. */
- if (DECL_ARTIFICIAL (t))
+ if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
+ && DECL_ARTIFICIAL (t))
dump_string_field (di, "note", "artificial");
if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
dump_child ("chan", TREE_CHAIN (t));
dump_int (di, "prec", TYPE_PRECISION (t));
break;
+ case FIXED_POINT_TYPE:
+ dump_int (di, "prec", TYPE_PRECISION (t));
+ dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
+ dump_string_field (di, "saturating",
+ TYPE_SATURATING (t) ? "saturating": "non-saturating");
+ break;
+
case POINTER_TYPE:
dump_child ("ptd", TREE_TYPE (t));
break;
case CONST_DECL:
dump_child ("cnst", DECL_INITIAL (t));
break;
+
+ case SYMBOL_MEMORY_TAG:
+ case NAME_MEMORY_TAG:
+ case STRUCT_FIELD_TAG:
+ break;
case VAR_DECL:
case PARM_DECL:
dump_int (di, "lngt", TREE_STRING_LENGTH (t));
break;
+ case REAL_CST:
+ dump_real (di, "valu", TREE_REAL_CST_PTR (t));
+ break;
+
+ case FIXED_CST:
+ dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
+ break;
+
case TRUTH_NOT_EXPR:
case ADDR_EXPR:
case INDIRECT_REF:
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
+ case GIMPLE_MODIFY_STMT:
+ dump_child ("op 0", GIMPLE_STMT_OPERAND (t, 0));
+ dump_child ("op 1", GIMPLE_STMT_OPERAND (t, 1));
+ break;
+
case COMPONENT_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case CALL_EXPR:
- dump_child ("fn", TREE_OPERAND (t, 0));
- dump_child ("args", TREE_OPERAND (t, 1));
+ {
+ int i = 0;
+ tree arg;
+ call_expr_arg_iterator iter;
+ dump_child ("fn", CALL_EXPR_FN (t));
+ FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
+ {
+ char buffer[32];
+ sprintf (buffer, "%u", i);
+ dump_child (buffer, arg);
+ i++;
+ }
+ }
break;
case CONSTRUCTOR:
- dump_child ("elts", CONSTRUCTOR_ELTS (t));
+ {
+ unsigned HOST_WIDE_INT cnt;
+ tree index, value;
+ dump_int (di, "lngt", VEC_length (constructor_elt,
+ CONSTRUCTOR_ELTS (t)));
+ FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
+ {
+ dump_child ("idx", index);
+ dump_child ("val", value);
+ }
+ }
break;
case BIND_EXPR:
case CASE_LABEL_EXPR:
dump_child ("name", CASE_LABEL (t));
- if (CASE_LOW (t)) {
- dump_child ("low ", CASE_LOW (t));
- if (CASE_HIGH (t)) {
- dump_child ("high", CASE_HIGH (t));
+ if (CASE_LOW (t))
+ {
+ dump_child ("low ", CASE_LOW (t));
+ if (CASE_HIGH (t))
+ dump_child ("high", CASE_HIGH (t));
}
- }
break;
case LABEL_EXPR:
dump_child ("name", TREE_OPERAND (t,0));
dump_child ("labl", TREE_OPERAND (t,2));
}
break;
+ case OMP_CLAUSE:
+ {
+ int i;
+ fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
+ for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
+ dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
+ }
+ break;
default:
/* There are no additional fields to print. */
break;
/* Return nonzero if FLAG has been specified for the dump, and NODE
is not the root node of the dump. */
-int dump_flag (dump_info_p di, int flag, tree node)
+int dump_flag (dump_info_p di, int flag, const_tree node)
{
return (di->flags & flag) && (node != di->node);
}
/* Dump T, and all its children, on STREAM. */
void
-dump_node (tree t, int flags, FILE *stream)
+dump_node (const_tree t, int flags, FILE *stream)
{
struct dump_info di;
dump_queue_p dq;
\f
/* Table of tree dump switches. This must be consistent with the
- TREE_DUMP_INDEX enumeration in tree.h */
+ tree_dump_index enumeration in tree-pass.h. */
static struct dump_file_info dump_files[TDI_end] =
{
{NULL, NULL, NULL, 0, 0, 0, 0},
- {".tu", "translation-unit", NULL, TDF_TREE, 0, 0, 0},
- {".class", "class-hierarchy", NULL, TDF_TREE, 0, 1, 0},
- {".original", "tree-original", NULL, TDF_TREE, 0, 2, 0},
- {".gimple", "tree-gimple", NULL, TDF_TREE, 0, 3, 0},
- {".nested", "tree-nested", NULL, TDF_TREE, 0, 4, 0},
- {".inlined", "tree-inlined", NULL, TDF_TREE, 0, 5, 0},
- {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 6, 0},
+ {".cgraph", "ipa-cgraph", NULL, TDF_IPA, 0, 0, 0},
+ {".tu", "translation-unit", NULL, TDF_TREE, 0, 1, 0},
+ {".class", "class-hierarchy", NULL, TDF_TREE, 0, 2, 0},
+ {".original", "tree-original", NULL, TDF_TREE, 0, 3, 0},
+ {".gimple", "tree-gimple", NULL, TDF_TREE, 0, 4, 0},
+ {".nested", "tree-nested", NULL, TDF_TREE, 0, 5, 0},
+ {".inlined", "tree-inlined", NULL, TDF_TREE, 0, 6, 0},
+ {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 7, 0},
+#define FIRST_AUTO_NUMBERED_DUMP 8
+
{NULL, "tree-all", NULL, TDF_TREE, 0, 0, 0},
{NULL, "rtl-all", NULL, TDF_RTL, 0, 0, 0},
{NULL, "ipa-all", NULL, TDF_IPA, 0, 0, 0},
-
- { ".cgraph", "ipa-cgraph", NULL, TDF_IPA, 0, 0, 0},
-
- { ".sibling", "rtl-sibling", NULL, TDF_RTL, 0, 1, 'i'},
- { ".eh", "rtl-eh", NULL, TDF_RTL, 0, 2, 'h'},
- { ".jump", "rtl-jump", NULL, TDF_RTL, 0, 3, 'j'},
- { ".cse", "rtl-cse", NULL, TDF_RTL, 0, 4, 's'},
- { ".gcse", "rtl-gcse", NULL, TDF_RTL, 0, 5, 'G'},
- { ".loop", "rtl-loop", NULL, TDF_RTL, 0, 6, 'L'},
- { ".bypass", "rtl-bypass", NULL, TDF_RTL, 0, 7, 'G'},
- { ".cfg", "rtl-cfg", NULL, TDF_RTL, 0, 8, 'f'},
- { ".bp", "rtl-bp", NULL, TDF_RTL, 0, 9, 'b'},
- { ".vpt", "rtl-vpt", NULL, TDF_RTL, 0, 10, 'V'},
- { ".ce1", "rtl-ce1", NULL, TDF_RTL, 0, 11, 'C'},
- { ".tracer", "rtl-tracer", NULL, TDF_RTL, 0, 12, 'T'},
- { ".loop2", "rtl-loop2", NULL, TDF_RTL, 0, 13, 'L'},
- { ".web", "rtl-web", NULL, TDF_RTL, 0, 14, 'Z'},
- { ".cse2", "rtl-cse2", NULL, TDF_RTL, 0, 15, 't'},
- { ".life", "rtl-life", NULL, TDF_RTL, 0, 16, 'f'},
- { ".combine", "rtl-combine", NULL, TDF_RTL, 0, 17, 'c'},
- { ".ce2", "rtl-ce2", NULL, TDF_RTL, 0, 18, 'C'},
- { ".regmove", "rtl-regmove", NULL, TDF_RTL, 0, 19, 'N'},
- { ".sms", "rtl-sms", NULL, TDF_RTL, 0, 20, 'm'},
- { ".sched", "rtl-sched", NULL, TDF_RTL, 0, 21, 'S'},
- { ".lreg", "rtl-lreg", NULL, TDF_RTL, 0, 22, 'l'},
- { ".greg", "rtl-greg", NULL, TDF_RTL, 0, 23, 'g'},
- { ".postreload", "rtl-postreload", NULL, TDF_RTL, 0, 24, 'o'},
- { ".gcse2", "rtl-gcse2", NULL, TDF_RTL, 0, 25, 'J'},
- { ".flow2", "rtl-flow2", NULL, TDF_RTL, 0, 26, 'w'},
- { ".peephole2", "rtl-peephole2", NULL, TDF_RTL, 0, 27, 'z'},
- { ".ce3", "rtl-ce3", NULL, TDF_RTL, 0, 28, 'E'},
- { ".rnreg", "rtl-rnreg", NULL, TDF_RTL, 0, 29, 'n'},
- { ".bbro", "rtl-bbro", NULL, TDF_RTL, 0, 30, 'B'},
- { ".btl", "rtl-btl", NULL, TDF_RTL, 0, 31, 'd'},
- { ".sched2", "rtl-sched2", NULL, TDF_RTL, 0, 32, 'R'},
- { ".stack", "rtl-stack", NULL, TDF_RTL, 0, 33, 'k'},
- { ".vartrack", "rtl-vartrack", NULL, TDF_RTL, 0, 34, 'V'},
- { ".mach", "rtl-mach", NULL, TDF_RTL, 0, 35, 'M'},
- { ".dbr", "rtl-dbr", NULL, TDF_RTL, 0, 36, 'd'}
};
/* Dynamically registered tree dump files and switches. */
{"lineno", TDF_LINENO},
{"uid", TDF_UID},
{"stmtaddr", TDF_STMTADDR},
+ {"memsyms", TDF_MEMSYMS},
{"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA
- | TDF_STMTADDR)},
+ | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC)},
{NULL, 0}
};
unsigned int
dump_register (const char *suffix, const char *swtch, const char *glob,
- int flags, unsigned int num, int letter)
+ int flags, int letter)
{
+ static int next_dump = FIRST_AUTO_NUMBERED_DUMP;
+ int num = next_dump++;
+
size_t this = extra_dump_files_in_use++;
if (this >= extra_dump_files_alloced)
char *
get_dump_file_name (enum tree_dump_index phase)
{
- char dump_id[7];
+ char dump_id[10];
struct dump_file_info *dfi;
if (phase == TDI_none)
dump_id[0] = '\0';
else
{
- const char *template;
+ char suffix;
if (dfi->flags & TDF_TREE)
- template = ".t%02d";
+ suffix = 't';
else if (dfi->flags & TDF_IPA)
- template = ".i%02d";
+ suffix = 'i';
else
- template = ".%02d";
+ suffix = 'r';
- if (snprintf (dump_id, sizeof (dump_id), template, dfi->num) < 0)
+ if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0)
dump_id[0] = '\0';
}
static int
dump_enable_all (int flags, int letter)
{
+ int ir_dump_type = (flags & (TDF_TREE | TDF_RTL | TDF_IPA));
int n = 0;
size_t i;
for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
- if ((dump_files[i].flags & flags)
+ if ((dump_files[i].flags & ir_dump_type)
&& (letter == 0 || letter == dump_files[i].letter))
{
dump_files[i].state = -1;
- dump_files[i].flags = flags;
+ dump_files[i].flags |= flags;
n++;
}
for (i = 0; i < extra_dump_files_in_use; i++)
- if ((extra_dump_files[i].flags & flags)
+ if ((extra_dump_files[i].flags & ir_dump_type)
&& (letter == 0 || letter == extra_dump_files[i].letter))
{
extra_dump_files[i].state = -1;
- extra_dump_files[i].flags = flags;
+ extra_dump_files[i].flags |= flags;
n++;
}
if (!option_value)
return 0;
+ if (*option_value && *option_value != '-')
+ return 0;
+
ptr = option_value;
flags = 0;
if (letter == 'a')
letter = 0;
- return dump_enable_all (TDF_RTL, letter) > 0;
+ return dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS, letter) > 0;
}