diff options
| -rw-r--r-- | gcc/ChangeLog | 23 | ||||
| -rw-r--r-- | gcc/Makefile.in | 6 | ||||
| -rw-r--r-- | gcc/c-common.c | 18 | ||||
| -rw-r--r-- | gcc/c-common.h | 36 | ||||
| -rw-r--r-- | gcc/c-decl.c | 12 | ||||
| -rw-r--r-- | gcc/c-dump.c | 768 | ||||
| -rw-r--r-- | gcc/c-lang.c | 3 | ||||
| -rw-r--r-- | gcc/c-semantics.c | 2 | ||||
| -rw-r--r-- | gcc/c-tree.h | 3 | ||||
| -rw-r--r-- | gcc/cp/ChangeLog | 21 | ||||
| -rw-r--r-- | gcc/cp/Make-lang.in | 4 | ||||
| -rw-r--r-- | gcc/cp/cp-tree.h | 27 | ||||
| -rw-r--r-- | gcc/cp/decl.c | 1 | ||||
| -rw-r--r-- | gcc/cp/decl2.c | 5 | ||||
| -rw-r--r-- | gcc/cp/dump.c | 809 | ||||
| -rw-r--r-- | gcc/cp/pt.c | 30 | ||||
| -rw-r--r-- | gcc/cp/typeck.c | 13 |
17 files changed, 933 insertions, 848 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 80db118..52dd9ce 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,26 @@ +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. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index a395d95..2ee1d5c 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -723,7 +723,7 @@ SUBDIR_FLAGS_TO_PASS = $(ORDINARY_FLAGS_TO_PASS) \ # 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) @@ -1224,6 +1224,10 @@ c-semantics.o : c-semantics.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) +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 = \ diff --git a/gcc/c-common.c b/gcc/c-common.c index 0482a83..c8e9c12 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -149,6 +149,11 @@ int flag_no_builtin; 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; @@ -5398,6 +5403,19 @@ self_promoting_args_p (parms) 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. */ diff --git a/gcc/c-common.h b/gcc/c-common.h index 1776bad..41e771c 100644 --- a/gcc/c-common.h +++ b/gcc/c-common.h @@ -379,6 +379,11 @@ extern int flag_no_builtin; 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; @@ -398,6 +403,14 @@ extern int warn_conversion; #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) \ @@ -480,6 +493,7 @@ extern tree build_va_arg PARAMS ((tree, tree)); 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. */ @@ -657,6 +671,14 @@ extern int anon_aggr_type_p PARAMS ((tree)); 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)); @@ -722,6 +744,20 @@ extern int c_safe_from_p PARAMS ((rtx, 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 diff --git a/gcc/c-decl.c b/gcc/c-decl.c index c1093ce..45dbb2c 100644 --- a/gcc/c-decl.c +++ b/gcc/c-decl.c @@ -510,6 +510,7 @@ c_decode_option (argc, argv) 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); @@ -667,6 +668,14 @@ c_decode_option (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")) @@ -5464,7 +5473,8 @@ finish_struct (t, fieldlist, attributes) "`%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) { diff --git a/gcc/c-dump.c b/gcc/c-dump.c new file mode 100644 index 0000000..30b0816 --- /dev/null +++ b/gcc/c-dump.c @@ -0,0 +1,768 @@ +/* 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); + } +} diff --git a/gcc/c-lang.c b/gcc/c-lang.c index 86e87b7..7259429 100644 --- a/gcc/c-lang.c +++ b/gcc/c-lang.c @@ -268,6 +268,9 @@ finish_file () 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 diff --git a/gcc/c-semantics.c b/gcc/c-semantics.c index f321063..8988680 100644 --- a/gcc/c-semantics.c +++ b/gcc/c-semantics.c @@ -283,7 +283,7 @@ make_rtl_for_local_static (decl) /* 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 diff --git a/gcc/c-tree.h b/gcc/c-tree.h index b8adce1..efd5083 100644 --- a/gcc/c-tree.h +++ b/gcc/c-tree.h @@ -140,9 +140,6 @@ struct lang_type 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) - /* in c-lang.c and objc-act.c */ extern tree lookup_interface PARAMS ((tree)); diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 384d8c2..9d79a4c 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,24 @@ +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 diff --git a/gcc/cp/Make-lang.in b/gcc/cp/Make-lang.in index 2099c3a..e8091f5 100644 --- a/gcc/cp/Make-lang.in +++ b/gcc/cp/Make-lang.in @@ -90,7 +90,7 @@ $(DEMANGLER_PROG): cxxmain.o underscore.o $(LIBDEPS) # 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 \ @@ -264,7 +264,7 @@ cp/errfn.o: cp/errfn.c $(CXX_TREE_H) toplev.h 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 diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index e7045e5..67e4c23 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -95,7 +95,7 @@ Boston, MA 02111-1307, USA. */ 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). @@ -1031,11 +1031,6 @@ extern int warn_ctor_dtor_privacy; 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 *'. */ @@ -1237,9 +1232,7 @@ enum languages { lang_c, lang_cplusplus, lang_java }; /* 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) \ @@ -2486,14 +2479,6 @@ extern int flag_new_for_scope; /* 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) @@ -4213,7 +4198,6 @@ extern void do_decl_instantiation PARAMS ((tree, tree, tree)); 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)); @@ -4546,7 +4530,6 @@ extern tree convert_for_initialization PARAMS ((tree, tree, tree, int, const ch 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)); @@ -4600,9 +4583,6 @@ extern void GNU_xref_assign PARAMS ((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)); @@ -4617,6 +4597,9 @@ extern tree mangle_thunk PARAMS ((tree, tree, 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 */ diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index ce19601..a66500f 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -6331,6 +6331,7 @@ init_decl_processing () 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 (); diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 138adc1..43874fb 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -236,11 +236,6 @@ int flag_optional_diags = 1; 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 *'. */ diff --git a/gcc/cp/dump.c b/gcc/cp/dump.c index 618a714..077b333 100644 --- a/gcc/cp/dump.c +++ b/gcc/cp/dump.c @@ -23,489 +23,52 @@ Boston, MA 02111-1307, USA. */ #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: @@ -515,60 +78,13 @@ dequeue_and_dump (di) 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)) @@ -625,34 +141,36 @@ dequeue_and_dump (di) 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; @@ -665,89 +183,12 @@ dequeue_and_dump (di) 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)); @@ -760,184 +201,10 @@ dequeue_and_dump (di) 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); - } -} diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 7098d7d..dd190ea 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -5654,7 +5654,7 @@ tsubst_decl (t, args, type, in_decl) /* 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; @@ -9871,34 +9871,6 @@ tsubst_initializer_list (t, argvec) 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 diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index db7374b..84b648c 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -6967,19 +6967,6 @@ comp_ptr_ttypes_reinterpret (to, from) } } -/* 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 |