/* Tree-dumping functionality for intermediate representation.
- Copyright (C) 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation, Inc.
Written by Mark Mitchell <mark@codesourcery.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 "tree-pass.h"
#include "langhooks.h"
#include "tree-iterator.h"
+#include "real.h"
static unsigned int queue (dump_info_p, 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);
static void dump_maybe_newline (dump_info_p);
-static void dump_string_field (dump_info_p, const char *, const char *);
static int dump_enable_all (int, int);
/* Add T to the end of the queue of nodes to dump. Returns the index
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,
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 string S. */
void
/* Dump the string field S. */
-static void
+void
dump_string_field (dump_info_p di, const char *field, const char *string)
{
dump_maybe_newline (di);
tree t;
unsigned int index;
enum tree_code code;
- char code_class;
+ enum tree_code_class code_class;
const char* code_name;
/* Get the next node from the queue. */
{
unsigned ix;
tree base;
- VEC (tree) *accesses = BINFO_BASE_ACCESSES (t);
+ VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
dump_child ("type", BINFO_TYPE (t));
if (BINFO_VIRTUAL_P (t))
- dump_string (di, "virt");
+ dump_string_field (di, "spec", "virt");
dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
else if (access == access_private_node)
string = "priv";
else
- abort ();
+ gcc_unreachable ();
- dump_string (di, string);
+ dump_string_field (di, "accs", string);
queue_and_dump_index (di, "binf", base, DUMP_BINFO);
}
switch (code_class)
{
- case '1':
+ case tcc_unary:
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
- case '2':
- case '<':
+ case tcc_binary:
+ case tcc_comparison:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
- case 'e':
- case 'r':
- case 's':
+ case tcc_expression:
+ case tcc_reference:
+ case tcc_statement:
+ case tcc_vl_exp:
/* These nodes are handled explicitly below. */
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
else if (DECL_P (t))
if (DECL_ASSEMBLER_NAME_SET_P (t)
&& DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
+ if (DECL_ABSTRACT_ORIGIN (t))
+ dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
/* And types. */
queue_and_dump_type (di, t);
dump_child ("scpe", DECL_CONTEXT (t));
di->column += 6 + strlen (filename) + 8;
}
/* And any declaration can be compiler-generated. */
- if (DECL_ARTIFICIAL (t))
- dump_string (di, "artificial");
+ 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));
}
- else if (code_class == 't')
+ else if (code_class == tcc_type)
{
/* All types have qualifiers. */
int quals = lang_hooks.tree_dump.type_quals (t);
/* All types have alignments. */
dump_int (di, "algn", TYPE_ALIGN (t));
}
- else if (code_class == 'c')
+ else if (code_class == tcc_constant)
/* All constants can have types. */
queue_and_dump_type (di, t);
case INTEGER_TYPE:
case ENUMERAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
- if (TYPE_UNSIGNED (t))
- dump_string (di, "unsigned");
+ dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_child ("min", TYPE_MIN_VALUE (t));
dump_child ("max", TYPE_MAX_VALUE (t));
case RECORD_TYPE:
case UNION_TYPE:
if (TREE_CODE (t) == RECORD_TYPE)
- dump_string (di, "struct");
+ dump_string_field (di, "tag", "struct");
else
- dump_string (di, "union");
+ dump_string_field (di, "tag", "union");
dump_child ("flds", TYPE_FIELDS (t));
dump_child ("fncs", TYPE_METHODS (t));
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, "used", TREE_USED (t));
if (DECL_REGISTER (t))
- dump_string (di, "register");
+ dump_string_field (di, "spec", "register");
}
break;
case FUNCTION_DECL:
dump_child ("args", DECL_ARGUMENTS (t));
if (DECL_EXTERNAL (t))
- dump_string (di, "undefined");
+ dump_string_field (di, "body", "undefined");
if (TREE_PUBLIC (t))
- dump_string (di, "extern");
+ dump_string_field (di, "link", "extern");
else
- dump_string (di, "static");
+ dump_string_field (di, "link", "static");
if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
dump_child ("body", DECL_SAVED_TREE (t));
break;
dump_int (di, "lngt", TREE_STRING_LENGTH (t));
break;
+ case REAL_CST:
+ dump_real (di, "valu", TREE_REAL_CST_PTR (t));
+ break;
+
case TRUTH_NOT_EXPR:
case ADDR_EXPR:
case INDIRECT_REF:
+ case ALIGN_INDIRECT_REF:
+ case MISALIGNED_INDIRECT_REF:
case CLEANUP_POINT_EXPR:
case SAVE_EXPR:
case REALPART_EXPR:
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));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
+ case TRY_FINALLY_EXPR:
+ 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:
dump_child ("cond", TREE_OPERAND (t, 0));
break;
+ case RETURN_EXPR:
+ dump_child ("expr", TREE_OPERAND (t, 0));
+ break;
+
case TARGET_EXPR:
dump_child ("decl", TREE_OPERAND (t, 0));
dump_child ("init", TREE_OPERAND (t, 1));
dump_child ("init", TREE_OPERAND (t, 3));
break;
+ 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));
+ }
+ break;
+ case LABEL_EXPR:
+ dump_child ("name", TREE_OPERAND (t,0));
+ break;
+ case GOTO_EXPR:
+ dump_child ("labl", TREE_OPERAND (t, 0));
+ break;
+ case SWITCH_EXPR:
+ dump_child ("cond", TREE_OPERAND (t, 0));
+ dump_child ("body", TREE_OPERAND (t, 1));
+ if (TREE_OPERAND (t, 2))
+ {
+ 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;
\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, 0, 0, 0, 0},
- {".tu", "translation-unit", TDF_TREE, 0, 0, 0},
- {".class", "class-hierarchy", TDF_TREE, 0, 1, 0},
- {".original", "tree-original", TDF_TREE, 0, 2, 0},
- {".generic", "tree-generic", TDF_TREE, 0, 3, 0},
- {".nested", "tree-nested", TDF_TREE, 0, 4, 0},
- {".inlined", "tree-inlined", TDF_TREE, 0, 5, 0},
- {".vcg", "tree-vcg", TDF_TREE, 0, 6, 0},
- /* FIXME -fdump-call-graph is broken. Set TDF_TREE when it is fixed. */
- {".xml", "call-graph", 0, 0, 7, 0},
- {NULL, "tree-all", TDF_TREE, 0, 0, 0},
- {NULL, "rtl-all", TDF_RTL, 0, 0, 0},
-
- { ".sibling", "rtl-sibling", TDF_RTL, 0, 1, 'i'},
- { ".eh", "rtl-eh", TDF_RTL, 0, 2, 'h'},
- { ".jump", "rtl-jump", TDF_RTL, 0, 3, 'j'},
- { ".cse", "rtl-cse", TDF_RTL, 0, 4, 's'},
- { ".gcse", "rtl-gcse", TDF_RTL, 0, 5, 'G'},
- { ".loop", "rtl-loop", TDF_RTL, 0, 6, 'L'},
- { ".bypass", "rtl-bypass", TDF_RTL, 0, 7, 'G'},
- { ".cfg", "rtl-cfg", TDF_RTL, 0, 8, 'f'},
- { ".bp", "rtl-bp", TDF_RTL, 0, 9, 'b'},
- { ".vpt", "rtl-vpt", TDF_RTL, 0, 10, 'V'},
- { ".ce1", "rtl-ce1", TDF_RTL, 0, 11, 'C'},
- { ".tracer", "rtl-tracer", TDF_RTL, 0, 12, 'T'},
- { ".loop2", "rtl-loop2", TDF_RTL, 0, 13, 'L'},
- { ".web", "rtl-web", TDF_RTL, 0, 14, 'Z'},
- { ".cse2", "rtl-cse2", TDF_RTL, 0, 15, 't'},
- { ".life", "rtl-life", TDF_RTL, 0, 16, 'f'},
- { ".combine", "rtl-combine", TDF_RTL, 0, 17, 'c'},
- { ".ce2", "rtl-ce2", TDF_RTL, 0, 18, 'C'},
- { ".regmove", "rtl-regmove", TDF_RTL, 0, 19, 'N'},
- { ".sms", "rtl-sms", TDF_RTL, 0, 20, 'm'},
- { ".sched", "rtl-sched", TDF_RTL, 0, 21, 'S'},
- { ".lreg", "rtl-lreg", TDF_RTL, 0, 22, 'l'},
- { ".greg", "rtl-greg", TDF_RTL, 0, 23, 'g'},
- { ".postreload", "rtl-postreload", TDF_RTL, 0, 24, 'o'},
- { ".gcse2", "rtl-gcse2", TDF_RTL, 0, 25, 'J'},
- { ".flow2", "rtl-flow2", TDF_RTL, 0, 26, 'w'},
- { ".peephole2", "rtl-peephole2", TDF_RTL, 0, 27, 'z'},
- { ".ce3", "rtl-ce3", TDF_RTL, 0, 28, 'E'},
- { ".rnreg", "rtl-rnreg", TDF_RTL, 0, 29, 'n'},
- { ".bbro", "rtl-bbro", TDF_RTL, 0, 30, 'B'},
- { ".btl", "rtl-btl", TDF_RTL, 0, 31, 'd'},
- { ".sched2", "rtl-sched2", TDF_RTL, 0, 32, 'R'},
- { ".stack", "rtl-stack", TDF_RTL, 0, 33, 'k'},
- { ".vartrack", "rtl-vartrack", TDF_RTL, 0, 34, 'V'},
- { ".mach", "rtl-mach", TDF_RTL, 0, 35, 'M'},
- { ".dbr", "rtl-dbr", TDF_RTL, 0, 36, 'd'}
+ {NULL, NULL, NULL, 0, 0, 0, 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},
};
/* Dynamically registered tree dump files and switches. */
{"vops", TDF_VOPS},
{"lineno", TDF_LINENO},
{"uid", TDF_UID},
- {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO)},
+ {"stmtaddr", TDF_STMTADDR},
+ {"memsyms", TDF_MEMSYMS},
+ {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA
+ | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC)},
{NULL, 0}
};
unsigned int
-dump_register (const char *suffix, const char *swtch, int flags,
- unsigned int num, int letter)
+dump_register (const char *suffix, const char *swtch, const char *glob,
+ 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)
memset (&extra_dump_files[this], 0, sizeof (struct dump_file_info));
extra_dump_files[this].suffix = suffix;
extra_dump_files[this].swtch = swtch;
+ extra_dump_files[this].glob = glob;
extra_dump_files[this].flags = flags;
extra_dump_files[this].num = num;
extra_dump_files[this].letter = letter;
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)
if (dfi->state == 0)
return NULL;
- if (dfi->num < 0
- || snprintf (dump_id, sizeof (dump_id), ".%s%02d",
- (dfi->flags & TDF_TREE) ? "t" : "", dfi->num) < 0)
+ if (dfi->num < 0)
dump_id[0] = '\0';
+ else
+ {
+ char suffix;
+ if (dfi->flags & TDF_TREE)
+ suffix = 't';
+ else if (dfi->flags & TDF_IPA)
+ suffix = 'i';
+ else
+ suffix = 'r';
+
+ if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0)
+ dump_id[0] = '\0';
+ }
return concat (dump_base_name, dump_id, dfi->suffix, NULL);
}
dfi = get_dump_file_info (phase);
stream = fopen (name, dfi->state < 0 ? "w" : "a");
if (!stream)
- error ("could not open dump file `%s': %s", name, strerror (errno));
+ error ("could not open dump file %qs: %s", name, strerror (errno));
else
dfi->state = 1;
free (name);
return stream;
}
-/* Returns nonzero if tree dump PHASE is enabled. */
+/* Returns nonzero if tree dump PHASE is enabled. If PHASE is
+ TDI_tree_all, return nonzero if any dump is enabled. */
int
dump_enabled_p (enum tree_dump_index phase)
{
- struct dump_file_info *dfi = get_dump_file_info (phase);
- return dfi->state;
+ if (phase == TDI_tree_all)
+ {
+ size_t i;
+ for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
+ if (dump_files[i].state)
+ return 1;
+ for (i = 0; i < extra_dump_files_in_use; i++)
+ if (extra_dump_files[i].state)
+ return 1;
+ return 0;
+ }
+ else
+ {
+ struct dump_file_info *dfi = get_dump_file_info (phase);
+ return dfi->state;
+ }
}
/* Returns nonzero if tree dump PHASE has been initialized. */
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++;
}
relevant details in the dump_files array. */
static int
-dump_switch_p_1 (const char *arg, struct dump_file_info *dfi)
+dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
{
const char *option_value;
const char *ptr;
int flags;
+
+ if (doglob && !dfi->glob)
+ return 0;
- option_value = skip_leading_substring (arg, dfi->swtch);
+ option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch);
if (!option_value)
return 0;
+ if (*option_value && *option_value != '-')
+ return 0;
+
ptr = option_value;
flags = 0;
flags |= option_ptr->value;
goto found;
}
- warning ("ignoring unknown option `%.*s' in `-fdump-%s'",
+ warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
length, ptr, dfi->swtch);
found:;
ptr = end_ptr;
int any = 0;
for (i = TDI_none + 1; i != TDI_end; i++)
- any |= dump_switch_p_1 (arg, &dump_files[i]);
+ any |= dump_switch_p_1 (arg, &dump_files[i], false);
+
+ /* Don't glob if we got a hit already */
+ if (!any)
+ for (i = TDI_none + 1; i != TDI_end; i++)
+ any |= dump_switch_p_1 (arg, &dump_files[i], true);
for (i = 0; i < extra_dump_files_in_use; i++)
- any |= dump_switch_p_1 (arg, &extra_dump_files[i]);
+ any |= dump_switch_p_1 (arg, &extra_dump_files[i], false);
+
+ if (!any)
+ for (i = 0; i < extra_dump_files_in_use; i++)
+ any |= dump_switch_p_1 (arg, &extra_dump_files[i], true);
+
return any;
}
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;
}