diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/tree-dump.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/tree-dump.c | 1091 |
1 files changed, 1091 insertions, 0 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/tree-dump.c b/gcc-4.2.1-5666.3/gcc/tree-dump.c new file mode 100644 index 000000000..d97dc83af --- /dev/null +++ b/gcc-4.2.1-5666.3/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; +} + + |