Skip to content

R
riscv-gcc-1
Commit 0a7394bc by Mark Mitchell Committed by Mark Mitchell
Options

Makefile.in (C_AND_OBJC_OBJS): Add c-dump.o. 

	* 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.

	* 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.

From-SVN: r37358
parent abffe289
Showing with 931 additions and 846 deletions
gcc/ChangeLog
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.
......
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 = \
......
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. */
......
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
......
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)
{
......
gcc/c-dump.c 0 → 100644
/* 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);
}
}
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
......
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
......
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));
......
gcc/cp/ChangeLog
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
......
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
......
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 */
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 ();
......
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 *'. */
......
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)
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)
int
cp_dump_tree (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 (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))
if (DECL_P (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");
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));
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 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 COMPOUND_STMT:
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);
}
}
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
......
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
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment