summaryrefslogtreecommitdiffstats
path: root/gcc/tree-dump.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/tree-dump.c')
-rw-r--r--gcc/tree-dump.c1091
1 files changed, 1091 insertions, 0 deletions
diff --git a/gcc/tree-dump.c b/gcc/tree-dump.c
new file mode 100644
index 0000000..d97dc83
--- /dev/null
+++ b/gcc/tree-dump.c
@@ -0,0 +1,1091 @@
+/* Tree-dumping functionality for intermediate representation.
+ 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.
+
+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
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+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. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "splay-tree.h"
+#include "diagnostic.h"
+#include "toplev.h"
+#include "tree-dump.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 int dump_enable_all (int, int);
+
+/* Add T to the end of the queue of nodes to dump. Returns the index
+ assigned to T. */
+
+static unsigned int
+queue (dump_info_p di, tree t, int flags)
+{
+ dump_queue_p dq;
+ dump_node_info_p dni;
+ unsigned int index;
+
+ /* Assign the next available index to T. */
+ index = ++di->index;
+
+ /* Obtain a new queue node. */
+ if (di->free_list)
+ {
+ dq = di->free_list;
+ di->free_list = dq->next;
+ }
+ else
+ dq = XNEW (struct dump_queue);
+
+ /* Create a new entry in the splay-tree. */
+ 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,
+ (splay_tree_value) dni);
+
+ /* Add it to the end of the queue. */
+ dq->next = 0;
+ if (!di->queue_end)
+ di->queue = dq;
+ else
+ di->queue_end->next = dq;
+ di->queue_end = dq;
+
+ /* Return the index. */
+ return index;
+}
+
+static void
+dump_index (dump_info_p di, unsigned int index)
+{
+ fprintf (di->stream, "@%-6u ", index);
+ di->column += 8;
+}
+
+/* If T has not already been output, queue it for subsequent output.
+ FIELD is a string to print before printing the index. Then, the
+ index of T is printed. */
+
+void
+queue_and_dump_index (dump_info_p di, const char *field, tree t, int flags)
+{
+ unsigned int index;
+ splay_tree_node n;
+
+ /* If there's no node, just return. This makes for fewer checks in
+ our callers. */
+ if (!t)
+ return;
+
+ /* See if we've already queued or dumped this node. */
+ n = splay_tree_lookup (di->nodes, (splay_tree_key) t);
+ if (n)
+ index = ((dump_node_info_p) n->value)->index;
+ else
+ /* If we haven't, add it to the queue. */
+ index = queue (di, t, flags);
+
+ /* Print the index of the node. */
+ dump_maybe_newline (di);
+ fprintf (di->stream, "%-4s: ", field);
+ di->column += 6;
+ dump_index (di, index);
+}
+
+/* Dump the type of T. */
+
+void
+queue_and_dump_type (dump_info_p di, tree t)
+{
+ queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
+}
+
+/* Dump column control */
+#define SOL_COLUMN 25 /* Start of line column. */
+#define EOL_COLUMN 55 /* End of line column. */
+#define COLUMN_ALIGNMENT 15 /* Alignment. */
+
+/* Insert a new line in the dump output, and indent to an appropriate
+ place to start printing more fields. */
+
+static void
+dump_new_line (dump_info_p di)
+{
+ fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
+ di->column = SOL_COLUMN;
+}
+
+/* If necessary, insert a new line. */
+
+static void
+dump_maybe_newline (dump_info_p di)
+{
+ int extra;
+
+ /* See if we need a new line. */
+ if (di->column > EOL_COLUMN)
+ dump_new_line (di);
+ /* See if we need any padding. */
+ else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
+ {
+ fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
+ di->column += COLUMN_ALIGNMENT - extra;
+ }
+}
+
+/* Dump pointer PTR using FIELD to identify it. */
+
+void
+dump_pointer (dump_info_p di, const char *field, void *ptr)
+{
+ dump_maybe_newline (di);
+ fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
+ di->column += 15;
+}
+
+/* Dump integer I using FIELD to identify it. */
+
+void
+dump_int (dump_info_p di, const char *field, int i)
+{
+ dump_maybe_newline (di);
+ fprintf (di->stream, "%-4s: %-7d ", field, i);
+ 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_string (dump_info_p di, const char *string)
+{
+ dump_maybe_newline (di);
+ fprintf (di->stream, "%-13s ", string);
+ if (strlen (string) > 13)
+ di->column += strlen (string) + 1;
+ else
+ di->column += 14;
+}
+
+/* Dump the string field S. */
+
+void
+dump_string_field (dump_info_p di, const char *field, const char *string)
+{
+ dump_maybe_newline (di);
+ fprintf (di->stream, "%-4s: %-7s ", field, string);
+ if (strlen (string) > 7)
+ di->column += 6 + strlen (string) + 1;
+ else
+ di->column += 14;
+}
+
+/* Dump the next node in the queue. */
+
+static void
+dequeue_and_dump (dump_info_p di)
+{
+ dump_queue_p dq;
+ splay_tree_node stn;
+ dump_node_info_p dni;
+ tree t;
+ unsigned int index;
+ enum tree_code code;
+ enum tree_code_class code_class;
+ const char* code_name;
+
+ /* Get the next node from the queue. */
+ dq = di->queue;
+ stn = dq->node;
+ t = (tree) stn->key;
+ dni = (dump_node_info_p) stn->value;
+ index = dni->index;
+
+ /* Remove the node from the queue, and put it on the free list. */
+ di->queue = dq->next;
+ if (!di->queue)
+ di->queue_end = 0;
+ dq->next = di->free_list;
+ di->free_list = dq;
+
+ /* Print the node index. */
+ dump_index (di, index);
+ /* And the type of node this is. */
+ if (dni->binfo_p)
+ code_name = "binfo";
+ else
+ code_name = tree_code_name[(int) TREE_CODE (t)];
+ fprintf (di->stream, "%-16s ", code_name);
+ di->column = 25;
+
+ /* Figure out what kind of node this is. */
+ code = TREE_CODE (t);
+ code_class = TREE_CODE_CLASS (code);
+
+ /* Although BINFOs are TREE_VECs, we dump them specially so as to be
+ more informative. */
+ if (dni->binfo_p)
+ {
+ unsigned ix;
+ tree base;
+ VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
+
+ dump_child ("type", BINFO_TYPE (t));
+
+ if (BINFO_VIRTUAL_P (t))
+ 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++)
+ {
+ tree access = (accesses ? VEC_index (tree, accesses, ix)
+ : access_public_node);
+ const char *string = NULL;
+
+ if (access == access_public_node)
+ string = "pub";
+ else if (access == access_protected_node)
+ string = "prot";
+ else if (access == access_private_node)
+ string = "priv";
+ else
+ gcc_unreachable ();
+
+ dump_string_field (di, "accs", string);
+ queue_and_dump_index (di, "binf", base, DUMP_BINFO);
+ }
+
+ goto done;
+ }
+
+ /* We can knock off a bunch of expression nodes in exactly the same
+ way. */
+ if (IS_EXPR_CODE_CLASS (code_class))
+ {
+ /* If we're dumping children, dump them now. */
+ queue_and_dump_type (di, t);
+
+ switch (code_class)
+ {
+ case tcc_unary:
+ dump_child ("op 0", TREE_OPERAND (t, 0));
+ break;
+
+ case tcc_binary:
+ case tcc_comparison:
+ dump_child ("op 0", TREE_OPERAND (t, 0));
+ dump_child ("op 1", TREE_OPERAND (t, 1));
+ break;
+
+ case tcc_expression:
+ case tcc_reference:
+ case tcc_statement:
+ /* These nodes are handled explicitly below. */
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+ }
+ else if (DECL_P (t))
+ {
+ expanded_location xloc;
+ /* All declarations have names. */
+ if (DECL_NAME (t))
+ dump_child ("name", DECL_NAME (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));
+ /* And a source position. */
+ xloc = expand_location (DECL_SOURCE_LOCATION (t));
+ if (xloc.file)
+ {
+ const char *filename = strrchr (xloc.file, '/');
+ if (!filename)
+ filename = xloc.file;
+ else
+ /* Skip the slash. */
+ ++filename;
+
+ dump_maybe_newline (di);
+ fprintf (di->stream, "srcp: %s:%-6d ", filename,
+ xloc.line);
+ di->column += 6 + strlen (filename) + 8;
+ }
+ /* And any declaration can be compiler-generated. */
+ 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 == tcc_type)
+ {
+ /* All types have qualifiers. */
+ int quals = lang_hooks.tree_dump.type_quals (t);
+
+ if (quals != TYPE_UNQUALIFIED)
+ {
+ fprintf (di->stream, "qual: %c%c%c ",
+ (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
+ (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
+ (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
+ di->column += 14;
+ }
+
+ /* All types have associated declarations. */
+ dump_child ("name", TYPE_NAME (t));
+
+ /* All types have a main variant. */
+ if (TYPE_MAIN_VARIANT (t) != t)
+ dump_child ("unql", TYPE_MAIN_VARIANT (t));
+
+ /* And sizes. */
+ dump_child ("size", TYPE_SIZE (t));
+
+ /* All types have alignments. */
+ dump_int (di, "algn", TYPE_ALIGN (t));
+ }
+ else if (code_class == tcc_constant)
+ /* All constants can have types. */
+ queue_and_dump_type (di, t);
+
+ /* Give the language-specific code a chance to print something. If
+ it's completely taken care of things, don't bother printing
+ anything more ourselves. */
+ if (lang_hooks.tree_dump.dump_tree (di, t))
+ goto done;
+
+ /* Now handle the various kinds of nodes. */
+ switch (code)
+ {
+ int i;
+
+ case IDENTIFIER_NODE:
+ dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
+ dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
+ break;
+
+ case TREE_LIST:
+ dump_child ("purp", TREE_PURPOSE (t));
+ dump_child ("valu", TREE_VALUE (t));
+ dump_child ("chan", TREE_CHAIN (t));
+ break;
+
+ case STATEMENT_LIST:
+ {
+ tree_stmt_iterator it;
+ for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
+ {
+ char buffer[32];
+ sprintf (buffer, "%u", i);
+ dump_child (buffer, tsi_stmt (it));
+ }
+ }
+ break;
+
+ case TREE_VEC:
+ dump_int (di, "lngt", TREE_VEC_LENGTH (t));
+ for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
+ {
+ char buffer[32];
+ sprintf (buffer, "%u", i);
+ dump_child (buffer, TREE_VEC_ELT (t, i));
+ }
+ break;
+
+ case INTEGER_TYPE:
+ case ENUMERAL_TYPE:
+ dump_int (di, "prec", TYPE_PRECISION (t));
+ dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
+ dump_child ("min", TYPE_MIN_VALUE (t));
+ dump_child ("max", TYPE_MAX_VALUE (t));
+
+ if (code == ENUMERAL_TYPE)
+ dump_child ("csts", TYPE_VALUES (t));
+ break;
+
+ case REAL_TYPE:
+ dump_int (di, "prec", TYPE_PRECISION (t));
+ break;
+
+ case POINTER_TYPE:
+ dump_child ("ptd", TREE_TYPE (t));
+ break;
+
+ case REFERENCE_TYPE:
+ dump_child ("refd", TREE_TYPE (t));
+ break;
+
+ case METHOD_TYPE:
+ dump_child ("clas", TYPE_METHOD_BASETYPE (t));
+ /* Fall through. */
+
+ case FUNCTION_TYPE:
+ dump_child ("retn", TREE_TYPE (t));
+ dump_child ("prms", TYPE_ARG_TYPES (t));
+ break;
+
+ case ARRAY_TYPE:
+ dump_child ("elts", TREE_TYPE (t));
+ dump_child ("domn", TYPE_DOMAIN (t));
+ break;
+
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ if (TREE_CODE (t) == RECORD_TYPE)
+ dump_string_field (di, "tag", "struct");
+ else
+ dump_string_field (di, "tag", "union");
+
+ dump_child ("flds", TYPE_FIELDS (t));
+ dump_child ("fncs", TYPE_METHODS (t));
+ queue_and_dump_index (di, "binf", TYPE_BINFO (t),
+ DUMP_BINFO);
+ 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:
+ case FIELD_DECL:
+ case RESULT_DECL:
+ if (TREE_CODE (t) == PARM_DECL)
+ dump_child ("argt", DECL_ARG_TYPE (t));
+ else
+ dump_child ("init", DECL_INITIAL (t));
+ dump_child ("size", DECL_SIZE (t));
+ dump_int (di, "algn", DECL_ALIGN (t));
+
+ if (TREE_CODE (t) == FIELD_DECL)
+ {
+ if (DECL_FIELD_OFFSET (t))
+ dump_child ("bpos", bit_position (t));
+ }
+ else if (TREE_CODE (t) == VAR_DECL
+ || TREE_CODE (t) == PARM_DECL)
+ {
+ dump_int (di, "used", TREE_USED (t));
+ if (DECL_REGISTER (t))
+ dump_string_field (di, "spec", "register");
+ }
+ break;
+
+ case FUNCTION_DECL:
+ dump_child ("args", DECL_ARGUMENTS (t));
+ if (DECL_EXTERNAL (t))
+ dump_string_field (di, "body", "undefined");
+ if (TREE_PUBLIC (t))
+ dump_string_field (di, "link", "extern");
+ else
+ 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;
+
+ case INTEGER_CST:
+ if (TREE_INT_CST_HIGH (t))
+ dump_int (di, "high", TREE_INT_CST_HIGH (t));
+ dump_int (di, "low", TREE_INT_CST_LOW (t));
+ break;
+
+ case STRING_CST:
+ fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
+ 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:
+ case IMAGPART_EXPR:
+ /* These nodes are unary, but do not have code class `1'. */
+ dump_child ("op 0", TREE_OPERAND (t, 0));
+ break;
+
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case INIT_EXPR:
+ case MODIFY_EXPR:
+ case COMPOUND_EXPR:
+ case PREDECREMENT_EXPR:
+ case PREINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
+ case POSTINCREMENT_EXPR:
+ /* These nodes are binary, but do not have code class `2'. */
+ dump_child ("op 0", TREE_OPERAND (t, 0));
+ dump_child ("op 1", TREE_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 ARRAY_REF:
+ case ARRAY_RANGE_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));
+ dump_child ("op 3", TREE_OPERAND (t, 3));
+ break;
+
+ case COND_EXPR:
+ 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));
+ break;
+
+ case CONSTRUCTOR:
+ {
+ 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 ("vars", TREE_OPERAND (t, 0));
+ dump_child ("body", TREE_OPERAND (t, 1));
+ break;
+
+ case LOOP_EXPR:
+ dump_child ("body", TREE_OPERAND (t, 0));
+ break;
+
+ case EXIT_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 ("clnp", TREE_OPERAND (t, 2));
+ /* There really are two possible places the initializer can be.
+ After RTL expansion, the second operand is moved to the
+ position of the fourth operand, and the second operand
+ becomes NULL. */
+ 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;
+ }
+
+ done:
+ if (dump_flag (di, TDF_ADDRESS, NULL))
+ dump_pointer (di, "addr", (void *)t);
+
+ /* Terminate the line. */
+ fprintf (di->stream, "\n");
+}
+
+/* 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)
+{
+ return (di->flags & flag) && (node != di->node);
+}
+
+/* Dump T, and all its children, on STREAM. */
+
+void
+dump_node (tree t, int flags, FILE *stream)
+{
+ struct dump_info di;
+ dump_queue_p dq;
+ dump_queue_p next_dq;
+
+ /* Initialize the dump-information structure. */
+ di.stream = stream;
+ di.index = 0;
+ di.column = 0;
+ di.queue = 0;
+ di.queue_end = 0;
+ di.free_list = 0;
+ di.flags = flags;
+ di.node = t;
+ di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
+ (splay_tree_delete_value_fn) &free);
+
+ /* Queue up the first node. */
+ queue (&di, t, DUMP_NONE);
+
+ /* Until the queue is empty, keep dumping nodes. */
+ while (di.queue)
+ dequeue_and_dump (&di);
+
+ /* Now, clean up. */
+ for (dq = di.free_list; dq; dq = next_dq)
+ {
+ next_dq = dq->next;
+ free (dq);
+ }
+ splay_tree_delete (di.nodes);
+}
+
+
+/* Table of tree dump switches. This must be consistent with the
+ TREE_DUMP_INDEX enumeration in tree.h. */
+static struct dump_file_info dump_files[TDI_end] =
+{
+ {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. */
+static struct dump_file_info *extra_dump_files;
+static size_t extra_dump_files_in_use;
+static size_t extra_dump_files_alloced;
+
+/* Define a name->number mapping for a dump flag value. */
+struct dump_option_value_info
+{
+ const char *const name; /* the name of the value */
+ const int value; /* the value of the name */
+};
+
+/* Table of dump options. This must be consistent with the TDF_* flags
+ in tree.h */
+static const struct dump_option_value_info dump_options[] =
+{
+ {"address", TDF_ADDRESS},
+ {"slim", TDF_SLIM},
+ {"raw", TDF_RAW},
+ {"details", TDF_DETAILS},
+ {"stats", TDF_STATS},
+ {"blocks", TDF_BLOCKS},
+ {"vops", TDF_VOPS},
+ {"lineno", TDF_LINENO},
+ {"uid", TDF_UID},
+ {"stmtaddr", TDF_STMTADDR},
+ {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA
+ | TDF_STMTADDR | TDF_GRAPH)},
+ {NULL, 0}
+};
+
+unsigned int
+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)
+ {
+ if (extra_dump_files_alloced == 0)
+ extra_dump_files_alloced = 32;
+ else
+ extra_dump_files_alloced *= 2;
+ extra_dump_files = xrealloc (extra_dump_files,
+ sizeof (struct dump_file_info)
+ * 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;
+
+ return this + TDI_end;
+}
+
+
+/* Return the dump_file_info for the given phase. */
+
+struct dump_file_info *
+get_dump_file_info (enum tree_dump_index phase)
+{
+ if (phase < TDI_end)
+ return &dump_files[phase];
+ else if (phase - TDI_end >= extra_dump_files_in_use)
+ return NULL;
+ else
+ return extra_dump_files + (phase - TDI_end);
+}
+
+
+/* Return the name of the dump file for the given phase.
+ If the dump is not enabled, returns NULL. */
+
+char *
+get_dump_file_name (enum tree_dump_index phase)
+{
+ char dump_id[10];
+ struct dump_file_info *dfi;
+
+ if (phase == TDI_none)
+ return NULL;
+
+ dfi = get_dump_file_info (phase);
+ if (dfi->state == 0)
+ return NULL;
+
+ 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);
+}
+
+/* Begin a tree dump for PHASE. Stores any user supplied flag in
+ *FLAG_PTR and returns a stream to write to. If the dump is not
+ enabled, returns NULL.
+ Multiple calls will reopen and append to the dump file. */
+
+FILE *
+dump_begin (enum tree_dump_index phase, int *flag_ptr)
+{
+ char *name;
+ struct dump_file_info *dfi;
+ FILE *stream;
+
+ if (phase == TDI_none || !dump_enabled_p (phase))
+ return NULL;
+
+ name = get_dump_file_name (phase);
+ dfi = get_dump_file_info (phase);
+ stream = fopen (name, dfi->state < 0 ? "w" : "a");
+ if (!stream)
+ error ("could not open dump file %qs: %s", name, strerror (errno));
+ else
+ dfi->state = 1;
+ free (name);
+
+ if (flag_ptr)
+ *flag_ptr = dfi->flags;
+
+ return stream;
+}
+
+/* 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)
+{
+ 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. */
+
+int
+dump_initialized_p (enum tree_dump_index phase)
+{
+ struct dump_file_info *dfi = get_dump_file_info (phase);
+ return dfi->state > 0;
+}
+
+/* Returns the switch name of PHASE. */
+
+const char *
+dump_flag_name (enum tree_dump_index phase)
+{
+ struct dump_file_info *dfi = get_dump_file_info (phase);
+ return dfi->swtch;
+}
+
+/* Finish a tree dump for PHASE. STREAM is the stream created by
+ dump_begin. */
+
+void
+dump_end (enum tree_dump_index phase ATTRIBUTE_UNUSED, FILE *stream)
+{
+ fclose (stream);
+}
+
+/* Enable all tree dumps. Return number of enabled tree dumps. */
+
+static int
+dump_enable_all (int flags, int letter)
+{
+ int ir_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 & ir_type)
+ && (letter == 0 || letter == dump_files[i].letter))
+ {
+ dump_files[i].state = -1;
+ dump_files[i].flags |= flags;
+ n++;
+ }
+
+ for (i = 0; i < extra_dump_files_in_use; i++)
+ if ((extra_dump_files[i].flags & ir_type)
+ && (letter == 0 || letter == extra_dump_files[i].letter))
+ {
+ extra_dump_files[i].state = -1;
+ extra_dump_files[i].flags |= flags;
+ n++;
+ }
+
+ return n;
+}
+
+/* Parse ARG as a dump switch. Return nonzero if it is, and store the
+ relevant details in the dump_files array. */
+
+static int
+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, doglob ? dfi->glob : dfi->swtch);
+ if (!option_value)
+ return 0;
+
+ ptr = option_value;
+ flags = 0;
+
+ while (*ptr)
+ {
+ const struct dump_option_value_info *option_ptr;
+ const char *end_ptr;
+ unsigned length;
+
+ while (*ptr == '-')
+ ptr++;
+ end_ptr = strchr (ptr, '-');
+ if (!end_ptr)
+ end_ptr = ptr + strlen (ptr);
+ length = end_ptr - ptr;
+
+ for (option_ptr = dump_options; option_ptr->name; option_ptr++)
+ if (strlen (option_ptr->name) == length
+ && !memcmp (option_ptr->name, ptr, length))
+ {
+ flags |= option_ptr->value;
+ goto found;
+ }
+ warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
+ length, ptr, dfi->swtch);
+ found:;
+ ptr = end_ptr;
+ }
+
+ dfi->state = -1;
+ dfi->flags |= flags;
+
+ /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
+ known dumps. */
+ if (dfi->suffix == NULL)
+ dump_enable_all (dfi->flags, 0);
+
+ return 1;
+}
+
+int
+dump_switch_p (const char *arg)
+{
+ size_t i;
+ int any = 0;
+
+ for (i = TDI_none + 1; i != TDI_end; 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], 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;
+}
+
+/* Dump FUNCTION_DECL FN as tree dump PHASE. */
+
+void
+dump_function (enum tree_dump_index phase, tree fn)
+{
+ FILE *stream;
+ int flags;
+
+ stream = dump_begin (phase, &flags);
+ if (stream)
+ {
+ dump_function_to_file (fn, stream, flags);
+ dump_end (phase, stream);
+ }
+}
+
+bool
+enable_rtl_dump_file (int letter)
+{
+ if (letter == 'a')
+ letter = 0;
+
+ return dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS, letter) > 0;
+}
+
+
OpenPOWER on IntegriCloud