+2000-11-09 Mark Mitchell <mark@codesourcery.com>
+
+ * Makefile.in (C_AND_OBJC_OBJS): Add c-dump.o.
+ (c-dump.o): New target.
+ * c-common.h (flag_dump_translation_unit): New variable.
+ (C_TYPE_QUALS): New macro.
+ (strip_array_types): New function.
+ (DECL_C_BIT_FIELD): New macro.
+ (SET_DECL_C_BIT_FIELD): Likewise.
+ (CLEAR_DECL_C_BIT_FIELD): Likewise.
+ (dump_info_p): New typedef.
+ (dump_tree_fn): Likewise.
+ (lang_dump_tree): New variable.
+ (dump_node_to_file): New function.
+ * c-common.c (flag_dump_translation_unit): Define it.
+ (strip_array_types): New function.
+ * c-decl.c (c_decode_option): Handle -fdump-translation-unit.
+ * c-lang.c (finish_file): Call dump_node_to_file if
+ flag_dump_translation_unit.
+ * c-semantics.c (mark_rtl_for_local_static): Fix typo in comment.
+ * c-tree.h (DECL_C_BIT_FIELD): Remove declaration.
+ * c-dump.c: New file.
+
2000-11-09 Christopher Faylor <cgf@cygnus.com>
* config/i386/cygwin.h: Add mingw startfile prefix.
# Language-specific object files for C and Objective C.
C_AND_OBJC_OBJS = c-errors.o c-lex.o c-pragma.o c-decl.o c-typeck.o \
- c-convert.o c-aux-info.o c-common.o c-semantics.o $(MAYBE_CPPLIB)
+ c-convert.o c-aux-info.o c-common.o c-semantics.o c-dump.o $(MAYBE_CPPLIB)
# Language-specific object files for C.
C_OBJS = c-parse.o c-lang.o $(C_AND_OBJC_OBJS)
c-lex.h flags.h toplev.h output.h c-pragma.h $(RTL_H) $(GGC_H) \
$(EXPR_H)
+c-dump.o: c-dump.c $(CONFIG_H) system.h $(TREE_H) $(C_TREE_H) \
+ c-lex.h flags.h toplev.h output.h c-pragma.h $(RTL_H) $(GGC_H) \
+ $(EXPR_H) $(SPLAY_TREE_H) c-dump.h
+
# Language-independent files.
DRIVER_DEFINES = \
int flag_no_nonansi_builtin;
+/* If non-NULL, dump the tree structure for the entire translation
+ unit to this file. */
+
+const char *flag_dump_translation_unit;
+
/* Nonzero means warn about possible violations of sequence point rules. */
int warn_sequence_point;
return 1;
}
+/* Recursively examines the array elements of TYPE, until a non-array
+ element type is found. */
+
+tree
+strip_array_types (type)
+ tree type;
+{
+ while (TREE_CODE (type) == ARRAY_TYPE)
+ type = TREE_TYPE (type);
+
+ return type;
+}
+
/* Recognize certain built-in functions so we can make tree-codes
other than CALL_EXPR. We do this when it enables fold-const.c
to do something useful. */
extern int flag_no_nonansi_builtin;
+/* If non-NULL, dump the tree structure for the entire translation
+ unit to this file. */
+
+extern const char *flag_dump_translation_unit;
+
/* Nonzero means warn about suggesting putting in ()'s. */
extern int warn_parentheses;
#define C_TYPE_FUNCTION_P(type) \
(TREE_CODE (type) == FUNCTION_TYPE)
+/* Return the qualifiers that apply to this type. In C++, that means
+ descending through array types. Note that this macro evaluates its
+ arguments mor than once. */
+#define C_TYPE_QUALS(TYPE) \
+ (TYPE_QUALS ((TREE_CODE (TYPE) == ARRAY_TYPE \
+ && c_language == clk_cplusplus) \
+ ? strip_array_types (TYPE) : TYPE))
+
/* For convenience we define a single macro to identify the class of
object or incomplete types. */
#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
extern int self_promoting_args_p PARAMS ((tree));
extern tree simple_type_promotes_to PARAMS ((tree));
+extern tree strip_array_types PARAMS ((tree));
/* These macros provide convenient access to the various _STMT nodes. */
sub-variables that make up the anonymous union. */
#define DECL_ANON_UNION_ELEMS(NODE) DECL_ARGUMENTS ((NODE))
+/* In a FIELD_DECL, nonzero if the decl was originally a bitfield. */
+#define DECL_C_BIT_FIELD(NODE) \
+ (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
+#define SET_DECL_C_BIT_FIELD(NODE) \
+ (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
+#define CLEAR_DECL_C_BIT_FIELD(NODE) \
+ (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
+
extern void emit_local_var PARAMS ((tree));
extern void make_rtl_for_local_static PARAMS ((tree));
extern tree expand_cond PARAMS ((tree));
#endif
+/* In dump.c */
+
+typedef struct dump_info *dump_info_p;
+
+/* A callback function used dump language-specific parts of tree
+ nodes. Returns non-zero if it does not want the usual dumping of
+ the second argument. */
+
+typedef int (*dump_tree_fn) PARAMS ((dump_info_p, tree));
+
+extern dump_tree_fn lang_dump_tree;
+
+extern void dump_node_to_file PARAMS ((tree, const char *));
+
/* Information recorded about each file examined during compilation. */
struct c_fileinfo
char **argv;
{
int strings_processed;
+ const char *option_value = NULL;
char *p = argv[0];
#if USE_CPPLIB
strings_processed = cpp_handle_option (&parse_in, argc, argv);
flag_no_builtin = 0;
else if (!strcmp (p, "-fno-builtin"))
flag_no_builtin = 1;
+ else if ((option_value
+ = skip_leading_substring (p, "-fdump-translation-unit-")))
+ {
+ if (p[22] == '\0')
+ error ("no file specified with -fdump-translation-unit");
+ else
+ flag_dump_translation_unit = option_value;
+ }
else if (!strcmp (p, "-ansi"))
goto iso_1990;
else if (!strcmp (p, "-Werror-implicit-function-declaration"))
"`%s' is narrower than values of its type");
DECL_SIZE (x) = bitsize_int (width);
- DECL_BIT_FIELD (x) = DECL_C_BIT_FIELD (x) = 1;
+ DECL_BIT_FIELD (x) = 1;
+ SET_DECL_C_BIT_FIELD (x);
if (width == 0)
{
--- /dev/null
+/* Tree-dumping functionality for intermediate representation.
+ Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+ Written by Mark Mitchell <mark@codesourcery.com>
+
+This file is part of GNU CC.
+
+GNU CC 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.
+
+GNU CC 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 GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+#include "config.h"
+#include "system.h"
+#include "tree.h"
+#include "c-common.h"
+#include "splay-tree.h"
+#include "diagnostic.h"
+#include "toplev.h"
+#include "c-dump.h"
+
+/* A callback function used dump language-specific parts of tree
+ nodes. Returns non-zero if it does not want the usual dumping of
+ the second argument. */
+
+dump_tree_fn lang_dump_tree;
+
+static unsigned int queue PARAMS ((dump_info_p, tree, int));
+static void dump_index PARAMS ((dump_info_p, unsigned int));
+static void dequeue_and_dump PARAMS ((dump_info_p));
+static void dump_new_line PARAMS ((dump_info_p));
+static void dump_maybe_newline PARAMS ((dump_info_p));
+static void dump_string_field PARAMS ((dump_info_p, const char *, const char *));
+static void dump_node PARAMS ((tree, FILE *));
+
+/* Add T to the end of the queue of nodes to dump. Returns the index
+ assigned to T. */
+
+static unsigned int
+queue (di, t, flags)
+ 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 = (dump_queue_p) xmalloc (sizeof (struct dump_queue));
+
+ /* Create a new entry in the splay-tree. */
+ dni = (dump_node_info_p) xmalloc (sizeof (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 (di, 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 (di, field, t, flags)
+ 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 (di, t)
+ dump_info_p di;
+ tree t;
+{
+ queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
+}
+
+/* Insert a new line in the dump output, and indent to an appropriate
+ place to start printing more fields. */
+
+static void
+dump_new_line (di)
+ dump_info_p di;
+{
+ fprintf (di->stream, "\n%25s", "");
+ di->column = 25;
+}
+
+/* If necessary, insert a new line. */
+
+static void
+dump_maybe_newline (di)
+ dump_info_p di;
+{
+ /* See if we need a new line. */
+ if (di->column > 53)
+ dump_new_line (di);
+ /* See if we need any padding. */
+ else if ((di->column - 25) % 14 != 0)
+ {
+ fprintf (di->stream, "%*s", 14 - ((di->column - 25) % 14), "");
+ di->column += 14 - (di->column - 25) % 14;
+ }
+}
+
+/* Dump I using FIELD to identity it. */
+
+void
+dump_int (di, field, i)
+ 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 string S. */
+
+void
+dump_string (di, 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. */
+
+static void
+dump_string_field (di, field, string)
+ 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 information common to statements from STMT. */
+
+void
+dump_stmt (di, t)
+ dump_info_p di;
+ tree t;
+{
+ dump_int (di, "line", STMT_LINENO (t));
+}
+
+/* Dump the next statement after STMT. */
+
+void
+dump_next_stmt (di, t)
+ dump_info_p di;
+ tree t;
+{
+ dump_child ("next", TREE_CHAIN (t));
+}
+
+/* Dump the next node in the queue. */
+
+static void
+dequeue_and_dump (di)
+ 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;
+ char 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)
+ {
+ if (TREE_VIA_PUBLIC (t))
+ dump_string (di, "pub");
+ else if (TREE_VIA_PROTECTED (t))
+ dump_string (di, "prot");
+ else if (TREE_VIA_PRIVATE (t))
+ dump_string (di, "priv");
+ if (TREE_VIA_VIRTUAL (t))
+ dump_string (di, "virt");
+
+ dump_child ("type", BINFO_TYPE (t));
+ dump_child ("base", BINFO_BASETYPES (t));
+
+ 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 '1':
+ dump_child ("op 0", TREE_OPERAND (t, 0));
+ break;
+
+ case '2':
+ case '<':
+ dump_child ("op 0", TREE_OPERAND (t, 0));
+ dump_child ("op 1", TREE_OPERAND (t, 1));
+ break;
+
+ case 'e':
+ /* These nodes are handled explicitly below. */
+ break;
+
+ default:
+ abort();
+ }
+ }
+ else if (DECL_P (t))
+ {
+ /* All declarations have names. */
+ if (DECL_NAME (t))
+ dump_child ("name", DECL_NAME (t));
+ if (DECL_ASSEMBLER_NAME (t)
+ && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
+ dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
+ /* And types. */
+ queue_and_dump_type (di, t);
+ dump_child ("scpe", DECL_CONTEXT (t));
+ /* And a source position. */
+ if (DECL_SOURCE_FILE (t))
+ {
+ const char *filename = strrchr (DECL_SOURCE_FILE (t), '/');
+ if (!filename)
+ filename = DECL_SOURCE_FILE (t);
+ else
+ /* Skip the slash. */
+ ++filename;
+
+ dump_maybe_newline (di);
+ fprintf (di->stream, "srcp: %s:%-6d ", filename,
+ DECL_SOURCE_LINE (t));
+ di->column += 6 + strlen (filename) + 8;
+ }
+ /* And any declaration can be compiler-generated. */
+ if (DECL_ARTIFICIAL (t))
+ dump_string (di, "artificial");
+ if (TREE_CHAIN (t))
+ dump_child ("chan", TREE_CHAIN (t));
+ }
+ else if (code_class == 't')
+ {
+ /* All types have qualifiers. */
+ int quals = C_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 == 'c')
+ /* 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_dump_tree && (*lang_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 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));
+ if (TREE_UNSIGNED (t))
+ dump_string (di, "unsigned");
+ 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 (di, "struct");
+ else
+ dump_string (di, "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 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_C_BIT_FIELD (t))
+ dump_string (di, "bitfield");
+ 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 (di, "register");
+ }
+ break;
+
+ case FUNCTION_DECL:
+ dump_child ("args", DECL_ARGUMENTS (t));
+ if (DECL_EXTERNAL (t))
+ dump_string (di, "undefined");
+ if (TREE_PUBLIC (t))
+ dump_string (di, "extern");
+ else
+ dump_string (di, "static");
+ break;
+
+ case ASM_STMT:
+ dump_stmt (di, t);
+ if (ASM_VOLATILE_P (t))
+ dump_string (di, "volatile");
+ dump_child ("strg", ASM_STRING (t));
+ dump_child ("outs", ASM_OUTPUTS (t));
+ dump_child ("ins", ASM_INPUTS (t));
+ dump_child ("clbr", ASM_CLOBBERS (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case BREAK_STMT:
+ case CONTINUE_STMT:
+ dump_stmt (di, t);
+ dump_next_stmt (di, t);
+ break;
+
+ case CASE_LABEL:
+ /* Note that a case label is not like other statments; there is
+ no way to get the line-number of a case label. */
+ dump_child ("low", CASE_LOW (t));
+ dump_child ("high", CASE_HIGH (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case COMPOUND_STMT:
+ dump_stmt (di, t);
+ dump_child ("body", COMPOUND_BODY (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case DECL_STMT:
+ dump_stmt (di, t);
+ dump_child ("decl", DECL_STMT_DECL (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case DO_STMT:
+ dump_stmt (di, t);
+ dump_child ("body", DO_BODY (t));
+ dump_child ("cond", DO_COND (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case EXPR_STMT:
+ dump_stmt (di, t);
+ dump_child ("expr", EXPR_STMT_EXPR (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case FOR_STMT:
+ dump_stmt (di, t);
+ dump_child ("init", FOR_INIT_STMT (t));
+ dump_child ("cond", FOR_COND (t));
+ dump_child ("expr", FOR_EXPR (t));
+ dump_child ("body", FOR_BODY (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case GOTO_STMT:
+ dump_stmt (di, t);
+ dump_child ("dest", GOTO_DESTINATION (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case IF_STMT:
+ dump_stmt (di, t);
+ dump_child ("cond", IF_COND (t));
+ dump_child ("then", THEN_CLAUSE (t));
+ dump_child ("else", ELSE_CLAUSE (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case LABEL_STMT:
+ dump_stmt (di, t);
+ dump_child ("labl", LABEL_STMT_LABEL (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case RETURN_STMT:
+ dump_stmt (di, t);
+ dump_child ("expr", RETURN_EXPR (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case SWITCH_STMT:
+ dump_stmt (di, t);
+ dump_child ("cond", SWITCH_COND (t));
+ dump_child ("body", SWITCH_BODY (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case WHILE_STMT:
+ dump_stmt (di, t);
+ dump_child ("cond", WHILE_COND (t));
+ dump_child ("body", WHILE_BODY (t));
+ dump_next_stmt (di, t);
+ break;
+
+ case SCOPE_STMT:
+ dump_stmt (di, t);
+ if (SCOPE_BEGIN_P (t))
+ dump_string (di, "begn");
+ else
+ dump_string (di, "end");
+ if (SCOPE_NULLIFIED_P (t))
+ dump_string (di, "null");
+ if (!SCOPE_NO_CLEANUPS_P (t))
+ dump_string (di, "clnp");
+ dump_next_stmt (di, 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 TRUTH_NOT_EXPR:
+ case ADDR_EXPR:
+ case INDIRECT_REF:
+ case CLEANUP_POINT_EXPR:
+ case SAVE_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 COMPONENT_REF:
+ case COMPOUND_EXPR:
+ case ARRAY_REF:
+ 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 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 CALL_EXPR:
+ dump_child ("fn", TREE_OPERAND (t, 0));
+ dump_child ("args", TREE_OPERAND (t, 1));
+ break;
+
+ case CONSTRUCTOR:
+ dump_child ("elts", TREE_OPERAND (t, 1));
+ break;
+
+ case STMT_EXPR:
+ dump_child ("stmt", STMT_EXPR_STMT (t));
+ 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 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 EXPR_WITH_FILE_LOCATION:
+ dump_child ("expr", EXPR_WFL_NODE (t));
+ break;
+
+ default:
+ /* There are no additional fields to print. */
+ break;
+ }
+
+ done:
+ /* Terminate the line. */
+ fprintf (di->stream, "\n");
+}
+
+/* Dump T, and all its children, on STREAM. */
+
+static void
+dump_node (t, stream)
+ tree t;
+ 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.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);
+}
+
+/* Dump T, and all its children, to FILE. */
+
+void
+dump_node_to_file (t, file)
+ tree t;
+ const char *file;
+{
+ FILE *f;
+
+ f = fopen (file, "w");
+ if (!f)
+ error ("could not open dump file `%s'", file);
+ else
+ {
+ dump_node (t, f);
+ fclose (f);
+ }
+}
if (back_end_hook)
(*back_end_hook) (getdecls ());
+
+ if (flag_dump_translation_unit)
+ dump_node_to_file (getdecls (), flag_dump_translation_unit);
}
/* Called during diagnostic message formatting process to print a
/* If the DECL_ASSEMBLER_NAME is not the same as the DECL_NAME, then
either we already created RTL for this DECL (and since it was a
- local variable, its DECL_ASSMEMBLER_NAME got hacked up to prevent
+ local variable, its DECL_ASSEMBLER_NAME got hacked up to prevent
clashes with other local statics with the same name by a previous
call to make_decl_rtl), or the user explicitly requested a
particular assembly name for this variable, using the GNU
without prototypes. */
#define TYPE_ACTUAL_ARG_TYPES(NODE) TYPE_NONCOPIED_PARTS (NODE)
-/* In a FIELD_DECL, nonzero if the decl was originally a bitfield. */
-#define DECL_C_BIT_FIELD(NODE) DECL_LANG_FLAG_4 (NODE)
-
\f
/* in c-lang.c and objc-act.c */
extern tree lookup_interface PARAMS ((tree));
+2000-11-09 Mark Mitchell <mark@codesourcery.com>
+
+ * Make-lang.in (CXX_C_OBJS): Add c-dump.o.
+ (dump.o): Update dependency list.
+ * cp-tree.h (DECL_MAYBE_TEMPLATE): Remove.
+ (flag_dump_translation_unit): Likewise.
+ (CP_TYPE_QUALS): Adjust definition.
+ (DECL_C_BIT_FIELD): Remove.
+ (SET_DECL_C_BIT_FIELD): Likewise.
+ (CLEAR_DECL_C_BIT_FIELD): Likewise.
+ (add_maybe_template): Likewise.
+ (strip_array_types): Likewise.
+ (dump_node_to_file): Likewise.
+ (cp_dump_tree): New function.
+ * decl.c (init_decl_processing): Set lang_dump_tree.
+ * decl2.c (flag_dump_translation_unit): Remove.
+ * dump.c: Move most of it to ../c-dump.c.
+ (cp_dump_tree): New function.
+ * pt.c (add_maybe_template): Remove.
+ * typeck.c (strip_array_types): Likewise.
+
2000-11-07 Eric Christopher <echristo@redhat.com>
* decl.c (init_decl_processing): Change definition of
# The compiler itself.
# Shared with C front end:
-CXX_C_OBJS = c-common.o c-pragma.o c-semantics.o c-lex.o
+CXX_C_OBJS = c-common.o c-pragma.o c-semantics.o c-lex.o c-dump.o
# Language-specific object files.
CXX_OBJS = cp/call.o cp/decl.o cp/errfn.o cp/expr.o cp/pt.o cp/typeck2.o \
cp/repo.o: cp/repo.c $(CXX_TREE_H) toplev.h $(GGC_H)
cp/semantics.o: cp/semantics.c $(CXX_TREE_H) cp/lex.h except.h toplev.h \
flags.h $(GGC_H) output.h $(RTL_H) $(TIMEVAR_H)
-cp/dump.o: cp/dump.c $(CXX_TREE_H)
+cp/dump.o: cp/dump.c $(CXX_TREE_H) c-dump.h
cp/optimize.o: cp/optimize.c $(CXX_TREE_H) rtl.h integrate.h insn-config.h \
input.h
cp/mangle.o: cp/mangle.c $(CXX_TREE_H) toplev.h
2: DECL_THIS_EXTERN (in VAR_DECL or FUNCTION_DECL).
DECL_IMPLICIT_TYPEDEF_P (in a TYPE_DECL)
3: DECL_IN_AGGR_P.
- 4: DECL_MAYBE_TEMPLATE.
+ 4: DECL_C_BIT_FIELD
5: DECL_INTERFACE_KNOWN.
6: DECL_THIS_STATIC (in VAR_DECL or FUNCTION_DECL).
7: DECL_DEAD_FOR_LOCAL (in VAR_DECL).
extern int warn_return_type;
-/* If non-NULL, dump the tree structure for the entire translation
- unit to this file. */
-
-extern const char *flag_dump_translation_unit;
-
/* Nonzero means warn about deprecated conversion from string constant to
`char *'. */
/* The type qualifiers for this type, including the qualifiers on the
elements for an array type. */
-#define CP_TYPE_QUALS(NODE) \
- ((TREE_CODE (NODE) != ARRAY_TYPE) \
- ? TYPE_QUALS (NODE) : cp_type_quals (NODE))
+#define CP_TYPE_QUALS(NODE) C_TYPE_QUALS (NODE)
/* Nonzero if this type is const-qualified. */
#define CP_TYPE_CONST_P(NODE) \
/* Record whether a typedef for type `int' was actually `signed int'. */
#define C_TYPEDEF_EXPLICITLY_SIGNED(exp) DECL_LANG_FLAG_1 ((exp))
-/* In a FIELD_DECL, nonzero if the decl was originally a bitfield. */
-#define DECL_C_BIT_FIELD(NODE) \
- (DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE)) == 1)
-#define SET_DECL_C_BIT_FIELD(NODE) \
- (DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE)) = 1)
-#define CLEAR_DECL_C_BIT_FIELD(NODE) \
- (DECL_LANG_FLAG_1 (FIELD_DECL_CHECK (NODE)) = 0)
-
/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
#define DECL_UNINLINABLE(NODE) \
(DECL_LANG_SPECIFIC (NODE)->decl_flags.uninlinable)
extern void do_type_instantiation PARAMS ((tree, tree, int));
extern tree instantiate_decl PARAMS ((tree, int));
extern tree get_bindings PARAMS ((tree, tree, tree));
-extern void add_maybe_template PARAMS ((tree, tree));
extern void pop_tinst_level PARAMS ((void));
extern int more_specialized_class PARAMS ((tree, tree));
extern int is_member_template PARAMS ((tree));
extern int comp_ptr_ttypes PARAMS ((tree, tree));
extern int ptr_reasonably_similar PARAMS ((tree, tree));
extern tree build_ptrmemfunc PARAMS ((tree, tree, int));
-extern tree strip_array_types PARAMS ((tree));
extern int cp_type_quals PARAMS ((tree));
extern int cp_has_mutable_p PARAMS ((tree));
extern int at_least_as_qualified_p PARAMS ((tree, tree));
extern void GNU_xref_hier PARAMS ((tree, tree, int, int, int));
extern void GNU_xref_member PARAMS ((tree, tree));
-/* in dump.c */
-extern void dump_node_to_file PARAMS ((tree, const char *));
-
/* in mangle.c */
extern void init_mangle PARAMS ((void));
extern tree mangle_decl PARAMS ((tree));
extern tree mangle_conv_op_name_for_type PARAMS ((tree));
extern tree mangle_guard_variable PARAMS ((tree));
+/* in dump.c */
+extern int cp_dump_tree PARAMS ((dump_info_p, tree));
+
/* -- end of C++ */
#endif /* not _CP_TREE_H */
free_lang_status = &pop_cp_function_context;
mark_lang_status = &mark_cp_function_context;
lang_safe_from_p = &c_safe_from_p;
+ lang_dump_tree = &cp_dump_tree;
cp_parse_init ();
init_decl2 ();
int flag_const_strings = 1;
-/* If non-NULL, dump the tree structure for the entire translation
- unit to this file. */
-
-const char *flag_dump_translation_unit = 0;
-
/* Nonzero means warn about deprecated conversion from string constant to
`char *'. */
#include "system.h"
#include "tree.h"
#include "cp-tree.h"
+#include "c-dump.h"
-/* Flags used with queue functions. */
-#define DUMP_NONE 0
-#define DUMP_BINFO 1
-
-/* Information about a node to be dumped. */
-
-typedef struct dump_node_info
-{
- /* The index for the node. */
- unsigned int index;
- /* Nonzero if the node is a binfo. */
- unsigned int binfo_p : 1;
-} *dump_node_info_p;
-
-/* A dump_queue is a link in the queue of things to be dumped. */
-
-typedef struct dump_queue
-{
- /* The queued tree node. */
- splay_tree_node node;
- /* The next node in the queue. */
- struct dump_queue *next;
-} *dump_queue_p;
-
-/* A dump_info gives information about how we should perform the dump
- and about the current state of the dump. */
-
-typedef struct dump_info
-{
- /* The stream on which to dump the information. */
- FILE *stream;
- /* The next unused node index. */
- unsigned int index;
- /* The next column. */
- unsigned int column;
- /* The first node in the queue of nodes to be written out. */
- dump_queue_p queue;
- /* The last node in the queue. */
- dump_queue_p queue_end;
- /* Free queue nodes. */
- dump_queue_p free_list;
- /* The tree nodes which we have already written out. The
- keys are the addresses of the nodes; the values are the integer
- indices we assigned them. */
- splay_tree nodes;
-} *dump_info_p;
-
-static unsigned int queue PARAMS ((dump_info_p, tree, int));
-static void dump_index PARAMS ((dump_info_p, unsigned int));
-static void queue_and_dump_index PARAMS ((dump_info_p, const char *, tree, int));
-static void queue_and_dump_type PARAMS ((dump_info_p, tree));
-static void dequeue_and_dump PARAMS ((dump_info_p));
-static void dump_new_line PARAMS ((dump_info_p));
-static void dump_maybe_newline PARAMS ((dump_info_p));
-static void dump_int PARAMS ((dump_info_p, const char *, int));
-static void dump_string PARAMS ((dump_info_p, const char *));
-static void dump_string_field PARAMS ((dump_info_p, const char *, const char *));
-static void dump_node PARAMS ((tree, FILE *));
-static void dump_stmt PARAMS ((dump_info_p, tree));
-static void dump_next_stmt PARAMS ((dump_info_p, tree));
-
-/* Add T to the end of the queue of nodes to dump. Returns the index
- assigned to T. */
-
-static unsigned int
-queue (di, t, flags)
- 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 = (dump_queue_p) xmalloc (sizeof (struct dump_queue));
-
- /* Create a new entry in the splay-tree. */
- dni = (dump_node_info_p) xmalloc (sizeof (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 (di, 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. */
-
-static void
-queue_and_dump_index (di, field, t, flags)
- 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. */
-
-static void
-queue_and_dump_type (di, t)
+int
+cp_dump_tree (di, t)
dump_info_p di;
tree t;
{
- queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE);
-}
-
-/* Insert a new line in the dump output, and indent to an appropriate
- place to start printing more fields. */
-
-static void
-dump_new_line (di)
- dump_info_p di;
-{
- fprintf (di->stream, "\n%25s", "");
- di->column = 25;
-}
-
-/* If necessary, insert a new line. */
-
-static void
-dump_maybe_newline (di)
- dump_info_p di;
-{
- /* See if we need a new line. */
- if (di->column > 53)
- dump_new_line (di);
- /* See if we need any padding. */
- else if ((di->column - 25) % 14 != 0)
- {
- fprintf (di->stream, "%*s", 14 - ((di->column - 25) % 14), "");
- di->column += 14 - (di->column - 25) % 14;
- }
-}
-
-/* Dump I using FIELD to identity it. */
-
-static void
-dump_int (di, field, i)
- 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 string S. */
-
-static void
-dump_string (di, 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. */
-
-static void
-dump_string_field (di, field, string)
- 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 information common to statements from STMT. */
-
-static void
-dump_stmt (di, t)
- dump_info_p di;
- tree t;
-{
- dump_int (di, "line", STMT_LINENO (t));
-}
-
-/* Dump the CHILD and its children. */
-#define dump_child(field, child) \
- queue_and_dump_index (di, field, child, DUMP_NONE)
-
-/* Dump the next statement after STMT. */
-
-static void
-dump_next_stmt (di, t)
- dump_info_p di;
- tree t;
-{
- dump_child ("next", TREE_CHAIN (t));
-}
-
-/* Dump the next node in the queue. */
-
-static void
-dequeue_and_dump (di)
- 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;
- char 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)
+ if (DECL_P (t))
{
- if (TREE_VIA_PUBLIC (t))
- dump_string (di, "pub");
- else if (TREE_VIA_PROTECTED (t))
- dump_string (di, "prot");
- else if (TREE_VIA_PRIVATE (t))
- dump_string (di, "priv");
- if (TREE_VIA_VIRTUAL (t))
- dump_string (di, "virt");
-
- dump_child ("type", BINFO_TYPE (t));
- dump_child ("base", BINFO_BASETYPES (t));
-
- 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 '1':
- dump_child ("op 0", TREE_OPERAND (t, 0));
- break;
-
- case '2':
- case '<':
- dump_child ("op 0", TREE_OPERAND (t, 0));
- dump_child ("op 1", TREE_OPERAND (t, 1));
- break;
-
- case 'e':
- /* These nodes are handled explicitly below. */
- break;
-
- default:
- my_friendly_abort (19990726);
- }
- }
- else if (code_class == 'd')
- {
- /* All declarations have names. */
- if (DECL_NAME (t))
- dump_child ("name", DECL_NAME (t));
- /* And types. */
- queue_and_dump_type (di, t);
- dump_child ("scpe", DECL_CONTEXT (t));
- /* And a source position. */
- if (DECL_SOURCE_FILE (t))
- {
- const char *filename = strrchr (DECL_SOURCE_FILE (t), '/');
- if (!filename)
- filename = DECL_SOURCE_FILE (t);
- else
- /* Skip the slash. */
- ++filename;
-
- dump_maybe_newline (di);
- fprintf (di->stream, "srcp: %s:%-6d ", filename,
- DECL_SOURCE_LINE (t));
- di->column += 6 + strlen (filename) + 8;
- }
- /* And any declaration can be compiler-generated. */
- if (DECL_ARTIFICIAL (t))
- dump_string (di, "artificial");
- if (TREE_CHAIN (t))
- dump_child ("chan", TREE_CHAIN (t));
if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
dump_string (di, language_to_string (DECL_LANGUAGE (t), 0));
}
- else if (code_class == 't')
- {
- /* All types have qualifiers. */
- int quals = CP_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 == 'c')
- /* All constants can have types. */
- queue_and_dump_type (di, t);
- /* Now handle the various kinds of nodes. */
switch (code)
{
- int i;
-
case IDENTIFIER_NODE:
if (IDENTIFIER_OPNAME_P (t))
- dump_string (di, "operator");
+ {
+ dump_string (di, "operator");
+ return 1;
+ }
else if (IDENTIFIER_TYPENAME_P (t))
- dump_child ("tynm", TREE_TYPE (t));
- else if (t == anonymous_namespace_name)
- dump_string (di, "unnamed");
- else
{
- dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
- dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
+ dump_child ("tynm", TREE_TYPE (t));
+ return 1;
}
- break;
-
- case TREE_LIST:
- dump_child ("purp", TREE_PURPOSE (t));
- dump_child ("valu", TREE_VALUE (t));
- dump_child ("chan", TREE_CHAIN (t));
- break;
-
- case TREE_VEC:
- dump_int (di, "lngt", TREE_VEC_LENGTH (t));
- for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
+ else if (t == anonymous_namespace_name)
{
- char buffer[32];
- sprintf (buffer, "%u", i);
- dump_child (buffer, TREE_VEC_ELT (t, i));
+ dump_string (di, "unnamed");
+ return 1;
}
break;
- case INTEGER_TYPE:
- case ENUMERAL_TYPE:
- dump_int (di, "prec", TYPE_PRECISION (t));
- if (TREE_UNSIGNED (t))
- dump_string (di, "unsigned");
- 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:
if (TYPE_PTRMEM_P (t))
{
dump_string (di, "ptrmem");
dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
+ return 1;
}
- else
- 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:
dump_string (di, "ptrmem");
dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
+ return 1;
}
- else
- {
- if (CLASSTYPE_DECLARED_CLASS (t))
- dump_string (di, "class");
- else if (TREE_CODE (t) == RECORD_TYPE)
- dump_string (di, "struct");
- else
- dump_string (di, "union");
-
- dump_child ("flds", TYPE_FIELDS (t));
- dump_child ("fncs", TYPE_METHODS (t));
- dump_child ("vfld", TYPE_VFIELD (t));
- queue_and_dump_index (di, "binf", TYPE_BINFO (t),
- DUMP_BINFO);
- }
- break;
-
- case CONST_DECL:
- dump_child ("cnst", DECL_INITIAL (t));
- 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_C_BIT_FIELD (t))
- dump_string (di, "bitfield");
- 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));
+ dump_child ("vfld", TYPE_VFIELD (t));
break;
case FUNCTION_DECL:
- dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
- dump_child ("args", DECL_ARGUMENTS (t));
- if (DECL_EXTERNAL (t))
- dump_string (di, "undefined");
- if (TREE_PUBLIC (t))
- dump_string(di, "extern");
- else
- dump_string (di, "static");
if (!DECL_THUNK_P (t))
{
if (DECL_FUNCTION_MEMBER_P (t))
dump_child ("chan", OVL_CHAIN (t));
break;
- case ASM_STMT:
+ case TRY_BLOCK:
dump_stmt (di, t);
- if (ASM_VOLATILE_P (t))
- dump_string (di, "volatile");
- dump_child ("strg", ASM_STRING (t));
- dump_child ("outs", ASM_OUTPUTS (t));
- dump_child ("ins", ASM_INPUTS (t));
- dump_child ("clbr", ASM_CLOBBERS (t));
+ if (CLEANUP_P (t))
+ dump_string (di, "cleanup");
+ dump_child ("body", TRY_STMTS (t));
+ dump_child ("hdlr", TRY_HANDLERS (t));
dump_next_stmt (di, t);
break;
- case BREAK_STMT:
- case CONTINUE_STMT:
- dump_stmt (di, t);
- dump_next_stmt (di, t);
+ case PTRMEM_CST:
+ dump_child ("clas", PTRMEM_CST_CLASS (t));
+ dump_child ("mbr", PTRMEM_CST_MEMBER (t));
break;
- case CASE_LABEL:
- /* Note that a case label is not like other statments; there is
- no way to get the line-number of a case label. */
- dump_child ("low", CASE_LOW (t));
- dump_child ("high", CASE_HIGH (t));
- dump_next_stmt (di, t);
+ case THROW_EXPR:
+ /* These nodes are unary, but do not have code class `1'. */
+ dump_child ("op 0", TREE_OPERAND (t, 0));
break;
- case COMPOUND_STMT:
+ case AGGR_INIT_EXPR:
+ dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
+ dump_child ("fn", TREE_OPERAND (t, 0));
+ dump_child ("args", TREE_OPERAND (t, 1));
+ dump_child ("decl", TREE_OPERAND (t, 2));
+ break;
+
+ case CLEANUP_STMT:
dump_stmt (di, t);
- dump_child ("body", COMPOUND_BODY (t));
+ dump_child ("decl", CLEANUP_DECL (t));
+ dump_child ("expr", CLEANUP_EXPR (t));
dump_next_stmt (di, t);
break;
dump_next_stmt (di, t);
break;
- case DECL_STMT:
- dump_stmt (di, t);
- dump_child ("decl", DECL_STMT_DECL (t));
- dump_next_stmt (di, t);
- break;
-
- case DO_STMT:
- dump_stmt (di, t);
- dump_child ("body", DO_BODY (t));
- dump_child ("cond", DO_COND (t));
- dump_next_stmt (di, t);
- break;
-
- case EXPR_STMT:
- dump_stmt (di, t);
- dump_child ("expr", EXPR_STMT_EXPR (t));
- dump_next_stmt (di, t);
- break;
-
- case FOR_STMT:
- dump_stmt (di, t);
- dump_child ("init", FOR_INIT_STMT (t));
- dump_child ("cond", FOR_COND (t));
- dump_child ("expr", FOR_EXPR (t));
- dump_child ("body", FOR_BODY (t));
- dump_next_stmt (di, t);
- break;
-
- case GOTO_STMT:
- dump_stmt (di, t);
- dump_child ("dest", GOTO_DESTINATION (t));
- dump_next_stmt (di, t);
- break;
-
case HANDLER:
dump_stmt (di, t);
dump_child ("body", HANDLER_BODY (t));
dump_next_stmt (di, t);
break;
- case IF_STMT:
- dump_stmt (di, t);
- dump_child ("cond", IF_COND (t));
- dump_child ("then", THEN_CLAUSE (t));
- dump_child ("else", ELSE_CLAUSE (t));
- dump_next_stmt (di, t);
- break;
-
- case LABEL_STMT:
- dump_stmt (di, t);
- dump_child ("labl", LABEL_STMT_LABEL (t));
- dump_next_stmt (di, t);
- break;
-
- case RETURN_STMT:
- dump_stmt (di, t);
- dump_child ("expr", RETURN_EXPR (t));
- dump_next_stmt (di, t);
- break;
-
- case SWITCH_STMT:
- dump_stmt (di, t);
- dump_child ("cond", SWITCH_COND (t));
- dump_child ("body", SWITCH_BODY (t));
- dump_next_stmt (di, t);
- break;
-
- case TRY_BLOCK:
- dump_stmt (di, t);
- if (CLEANUP_P (t))
- dump_string (di, "cleanup");
- dump_child ("body", TRY_STMTS (t));
- dump_child ("hdlr", TRY_HANDLERS (t));
- dump_next_stmt (di, t);
- break;
-
- case WHILE_STMT:
- dump_stmt (di, t);
- dump_child ("cond", WHILE_COND (t));
- dump_child ("body", WHILE_BODY (t));
- dump_next_stmt (di, t);
- break;
-
case SUBOBJECT:
dump_stmt (di, t);
dump_child ("clnp", TREE_OPERAND (t, 0));
dump_next_stmt (di, t);
break;
- case CLEANUP_STMT:
- dump_stmt (di, t);
- dump_child ("decl", CLEANUP_DECL (t));
- dump_child ("expr", CLEANUP_EXPR (t));
- dump_next_stmt (di, t);
- break;
-
- case SCOPE_STMT:
- dump_stmt (di, t);
- if (SCOPE_BEGIN_P (t))
- dump_string (di, "begn");
- else
- dump_string (di, "end");
- if (SCOPE_NULLIFIED_P (t))
- dump_string (di, "null");
- if (!SCOPE_NO_CLEANUPS_P (t))
- dump_string (di, "clnp");
- dump_next_stmt (di, 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 PTRMEM_CST:
- dump_child ("clas", PTRMEM_CST_CLASS (t));
- dump_child ("mbr", PTRMEM_CST_MEMBER (t));
- break;
-
- case TRUTH_NOT_EXPR:
- case ADDR_EXPR:
- case INDIRECT_REF:
- case THROW_EXPR:
- case CLEANUP_POINT_EXPR:
- case SAVE_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 COMPONENT_REF:
- case COMPOUND_EXPR:
- case ARRAY_REF:
- 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 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 CALL_EXPR:
- dump_child ("fn", TREE_OPERAND (t, 0));
- dump_child ("args", TREE_OPERAND (t, 1));
- break;
-
- case CONSTRUCTOR:
- dump_child ("elts", TREE_OPERAND (t, 1));
- break;
-
- case STMT_EXPR:
- dump_child ("stmt", STMT_EXPR_STMT (t));
- 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 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 AGGR_INIT_EXPR:
- dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
- dump_child ("fn", TREE_OPERAND (t, 0));
- dump_child ("args", TREE_OPERAND (t, 1));
- dump_child ("decl", TREE_OPERAND (t, 2));
- break;
-
- case EXPR_WITH_FILE_LOCATION:
- dump_child ("expr", EXPR_WFL_NODE (t));
- break;
-
default:
- /* There are no additional fields to print. */
break;
}
- done:
- /* Terminate the line. */
- fprintf (di->stream, "\n");
+ return 0;
}
-/* Dump T, and all its children, on STREAM. */
-
-static void
-dump_node (t, stream)
- tree t;
- 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.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);
-}
-
-/* Dump T, and all its children, to FILE. */
-
-void
-dump_node_to_file (t, file)
- tree t;
- const char *file;
-{
- FILE *f;
-
- f = fopen (file, "w");
- if (!f)
- cp_error ("could not open `%s'", file);
- else
- {
- dump_node (t, f);
- fclose (f);
- }
-}
/* We do NOT check for matching decls pushed separately at this
point, as they may not represent instantiations of this
template, and in any case are considered separate under the
- discrete model. Instead, see add_maybe_template. */
+ discrete model. */
r = copy_decl (t);
DECL_USE_TEMPLATE (r) = 0;
TREE_TYPE (r) = type;
return first;
}
-/* D is an undefined function declaration in the presence of templates with
- the same name, listed in FNS. If one of them can produce D as an
- instantiation, remember this so we can instantiate it at EOF if D has
- not been defined by that time. */
-
-void
-add_maybe_template (d, fns)
- tree d, fns;
-{
- tree t;
-
- if (DECL_MAYBE_TEMPLATE (d))
- return;
-
- t = most_specialized (fns, d, NULL_TREE);
- if (! t)
- return;
- if (t == error_mark_node)
- {
- cp_error ("ambiguous template instantiation for `%D'", d);
- return;
- }
-
- *maybe_template_tail = tree_cons (t, d, NULL_TREE);
- maybe_template_tail = &TREE_CHAIN (*maybe_template_tail);
- DECL_MAYBE_TEMPLATE (d) = 1;
-}
-
/* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
static void
}
}
-/* Recursively examines the array elements of TYPE, until a non-array
- element type is found. */
-
-tree
-strip_array_types (type)
- tree type;
-{
- while (TREE_CODE (type) == ARRAY_TYPE)
- type = TREE_TYPE (type);
-
- return type;
-}
-
/* Returns the type-qualifier set corresponding to TYPE. */
int
projects / thirdparty / gcc.git / commitdiff
