procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tree-dump.c: Rename from c-dump.c.

Browse source 
* tree-dump.c: Rename from c-dump.c. Include c-tree.h, not c-common.h.
	(lang_type_quals): Declare.
	(dequeue_and_dump): Use lang_hooks.tree_dump.type_quals function to
	retrieve language-specific qualifiers for a type node, instead of
	C_TYPE_QUALS. Likewise for lang_hooks.tree_dump.dump_tree instead of
	lang_dump_tree.
	* tree-dump.h: Rename from c-dump.h.
	* c-common.h (C_TYPE_QUALS): Removed.
	Move declarations for tree-dump.c interface to...
	* tree.h: ... here. Remove lang_dump_tree.
	* langhooks.h (struct lang_hooks_for_tree_dump): New.
	(struct lang_hooks): Add tree_dump hooks.
	* langhooks.c (lhd_tree_dump_dump_tree): New function.
	(lhd_tree_dump_type_quals): New function.
	* langhooks-def.h (lhd_tree_dump_dump_tree, lhd_tree_dump_type_quals):
	Declare.
	(LANG_HOOKS_INITIALIZER): Add tree_dump hooks.
	* Makefile.in: Move tree-dump.o to language-independent back-end.

cp:
	* cp-tree.h (CP_TYPE_QUALS): Removed.
	* decl.c (cxx_init_decl_processing): Don't set lang_dump_tree.
	* cp-lang.c: Set LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN and
	LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN.
	* dump.c (cp_dump_tree): Use void* dump_info argument to match
	lang-hooks prototype.
	* call.c, cp-tree.h, cvt.c, decl.c, init.c, mangle.c, method.c, pt.c,
	rtti.c, semantics.c, tree.c, typeck.c, typeck2.c: All references to
	CP_TYPE_QUALS changed to cp_type_quals.
	* Make-lang.in: References to c-dump.h changed to tree-dump.h.
	(CXX_C_OBJS): Remove c-dump.o.

From-SVN: r47257
This commit is contained in:
Bryce McKinlay 2001-11-22 02:33:02 +00:00 • committed by Bryce McKinlay
parent 4617e3b52b
commit 89d684bba3
28 changed files with 203 additions and 1161 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
gcc/ChangeLog
View file

@ -1,3 +1,24 @@
2001-11-21 Bryce McKinlay <bryce@waitaki.otago.ac.nz>
* tree-dump.c: Rename from c-dump.c. Include c-tree.h, not c-common.h.
(lang_type_quals): Declare.
(dequeue_and_dump): Use lang_hooks.tree_dump.type_quals function to
retrieve language-specific qualifiers for a type node, instead of
C_TYPE_QUALS. Likewise for lang_hooks.tree_dump.dump_tree instead of
lang_dump_tree.
* tree-dump.h: Rename from c-dump.h.
* c-common.h (C_TYPE_QUALS): Removed.
Move declarations for tree-dump.c interface to...
* tree.h: ... here. Remove lang_dump_tree.
* langhooks.h (struct lang_hooks_for_tree_dump): New.
(struct lang_hooks): Add tree_dump hooks.
* langhooks.c (lhd_tree_dump_dump_tree): New function.
(lhd_tree_dump_type_quals): New function.
* langhooks-def.h (lhd_tree_dump_dump_tree, lhd_tree_dump_type_quals):
Declare.
(LANG_HOOKS_INITIALIZER): Add tree_dump hooks.
* Makefile.in: Move tree-dump.o to language-independent back-end.
2001-11-21 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* 1750a.h (DBX_REGISTER_NUMBER): Don't define.

14
gcc/Makefile.in
View file

@ -723,7 +723,7 @@ CXX_TARGET_OBJS=@cxx_target_objs@
# Language-specific object files for C and Objective C.
C_AND_OBJC_OBJS = attribs.o 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-format.o c-semantics.o c-dump.o \
c-convert.o c-aux-info.o c-common.o c-format.o c-semantics.o \
libcpp.a $(C_TARGET_OBJS)
# Language-specific object files for C.
@ -745,8 +745,9 @@ OBJS = alias.o bb-reorder.o bitmap.o builtins.o caller-save.o calls.o \
reload.o reload1.o reorg.o resource.o rtl.o rtlanal.o rtl-error.o \
sbitmap.o sched-deps.o sched-ebb.o sched-rgn.o sched-vis.o sdbout.o \
sibcall.o simplify-rtx.o splay-tree.o ssa.o ssa-ccp.o ssa-dce.o stmt.o \
stor-layout.o stringpool.o timevar.o toplev.o tree.o tree-inline.o \
unroll.o varasm.o varray.o version.o xcoffout.o cfglayout.o \
stor-layout.o stringpool.o timevar.o toplev.o tree.o tree-dump.o \
tree-inline.o unroll.o varasm.o varray.o version.o xcoffout.o \
cfglayout.o \
$(GGC) $(out_object_file) $(EXTRA_OBJS)
BACKEND = main.o libbackend.a
@ -1264,10 +1265,6 @@ 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 = \
@ -1352,6 +1349,9 @@ langhooks.o : langhooks.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) toplev.h \
tree-inline.h $(RTL_H) insn-config.h integrate.h langhooks.h langhooks-def.h
tree.o : tree.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) flags.h function.h toplev.h \
$(GGC_H) $(HASHTAB_H) $(TARGET_H) output.h $(TM_P_H) langhooks.h
tree-dump.o: tree-dump.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(C_TREE_H) \
flags.h langhooks.h toplev.h output.h c-pragma.h $(RTL_H) $(GGC_H) \
$(EXPR_H) $(SPLAY_TREE_H) tree-dump.h
tree-inline.o : tree-inline.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(RTL_H) \
expr.h flags.h params.h input.h insn-config.h $(INTEGRATE_H) \
$(VARRAY_H) $(HASHTAB_H) $(SPLAY_TREE_H) toplev.h langhooks.h \

47
gcc/c-common.h
View file

@ -457,14 +457,6 @@ extern int warn_long_long;
#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 more 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) \
@ -819,45 +811,6 @@ extern int c_safe_from_p PARAMS ((rtx, tree));
extern int c_unsafe_for_reeval PARAMS ((tree));
/* In c-dump.c */
/* Different tree dump places. When you add new tree dump places,
extend the DUMP_FILES array in c-dump.c */
enum tree_dump_index
{
TDI_all, /* dump the whole translation unit */
TDI_class, /* dump class hierarchy */
TDI_original, /* dump each function before optimizing it */
TDI_optimized, /* dump each function after optimizing it */
TDI_inlined, /* dump each function after inlining
within it. */
TDI_end
};
/* Bit masks to control tree dumping. Not all values are applicable to
all tree dumps. Add new ones at the end. When you define new
values, extend the DUMP_OPTIONS array in c-dump.c */
#define TDF_ADDRESS (1 << 0) /* dump node addresses */
#define TDF_SLIM (1 << 1) /* don't go wild following links */
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 int dump_flag PARAMS ((dump_info_p, int, tree));
extern int dump_enabled_p PARAMS ((enum tree_dump_index));
extern FILE *dump_begin PARAMS ((enum tree_dump_index, int *));
extern void dump_end PARAMS ((enum tree_dump_index, FILE *));
extern void dump_node PARAMS ((tree, int, FILE *));
extern int dump_switch_p PARAMS ((const char *));
extern const char *dump_flag_name PARAMS ((enum tree_dump_index));
/* Information recorded about each file examined during compilation. */
struct c_fileinfo

933
gcc/c-dump.c
View file

@ -1,933 +0,0 @@
/* 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 GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 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 *));
/* 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);
}
/* Dump column control */
#define SOL_COLUMN 25 /* Start of line column. */
#define EOL_COLUMN 55 /* End of line column. */
#define COLUMN_ALIGNMENT 15 /* Alignment. */
/* Insert a new line in the dump output, and indent to an appropriate
place to start printing more fields. */
static void
dump_new_line (di)
dump_info_p di;
{
fprintf (di->stream, "\n%*s", SOL_COLUMN, "");
di->column = SOL_COLUMN;
}
/* If necessary, insert a new line. */
static void
dump_maybe_newline (di)
dump_info_p di;
{
int extra;
/* See if we need a new line. */
if (di->column > EOL_COLUMN)
dump_new_line (di);
/* See if we need any padding. */
else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0)
{
fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, "");
di->column += COLUMN_ALIGNMENT - extra;
}
}
/* Dump pointer PTR using FIELD to identify it. */
void
dump_pointer (di, field, ptr)
dump_info_p di;
const char *field;
void *ptr;
{
dump_maybe_newline (di);
fprintf (di->stream, "%-4s: %-8lx ", field, (long) ptr);
di->column += 15;
}
/* Dump integer I using FIELD to identify it. */
void
dump_int (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_SET_P (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_flag (di, TDF_SLIM, NULL))
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");
if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
dump_child ("body", DECL_SAVED_TREE (t));
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 statements; 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:
if (dump_flag (di, TDF_ADDRESS, NULL))
dump_pointer (di, "addr", (void *)t);
/* Terminate the line. */
fprintf (di->stream, "\n");
}
/* Return non-zero if FLAG has been specified for the dump, and NODE
is not the root node of the dump. */
int dump_flag (di, flag, node)
dump_info_p di;
int flag;
tree node;
{
return (di->flags & flag) && (node != di->node);
}
/* Dump T, and all its children, on STREAM. */
void
dump_node (t, flags, stream)
tree t;
int flags;
FILE *stream;
{
struct dump_info di;
dump_queue_p dq;
dump_queue_p next_dq;
/* Initialize the dump-information structure. */
di.stream = stream;
di.index = 0;
di.column = 0;
di.queue = 0;
di.queue_end = 0;
di.free_list = 0;
di.flags = flags;
di.node = t;
di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
(splay_tree_delete_value_fn) &free);
/* Queue up the first node. */
queue (&di, t, DUMP_NONE);
/* Until the queue is empty, keep dumping nodes. */
while (di.queue)
dequeue_and_dump (&di);
/* Now, clean up. */
for (dq = di.free_list; dq; dq = next_dq)
{
next_dq = dq->next;
free (dq);
}
splay_tree_delete (di.nodes);
}
/* Define a tree dump switch. */
struct dump_file_info
{
const char *suffix; /* suffix to give output file. */
const char *swtch; /* command line switch */
int flags; /* user flags */
int state; /* state of play */
};
/* Table of tree dump switches. This must be consistent with the
TREE_DUMP_INDEX enumeration in c-common.h */
static struct dump_file_info dump_files[TDI_end] =
{
{".tu", "dump-translation-unit", 0, 0},
{".class", "dump-class-hierarchy", 0, 0},
{".original", "dump-tree-original", 0, 0},
{".optimized", "dump-tree-optimized", 0, 0},
{".inlined", "dump-tree-inlined", 0, 0},
};
/* Define a name->number mapping for a dump flag value. */
struct dump_option_value_info
{
const char *const name; /* the name of the value */
const int value; /* the value of the name */
};
/* Table of dump options. This must be consistent with the TDF_* flags
in c-common.h */
static const struct dump_option_value_info dump_options[] =
{
{"address", TDF_ADDRESS},
{"slim", TDF_SLIM},
{"all", ~0},
{NULL, 0}
};
/* Begin a tree dump for PHASE. Stores any user supplied flag in
*FLAG_PTR and returns a stream to write to. If the dump is not
enabled, returns NULL.
Multiple calls will reopen and append to the dump file. */
FILE *
dump_begin (phase, flag_ptr)
enum tree_dump_index phase;
int *flag_ptr;
{
FILE *stream;
char *name;
if (!dump_files[phase].state)
return NULL;
name = concat (dump_base_name, dump_files[phase].suffix, NULL);
stream = fopen (name, dump_files[phase].state < 0 ? "w" : "a");
if (!stream)
error ("could not open dump file `%s'", name);
else
dump_files[phase].state = 1;
free (name);
if (flag_ptr)
*flag_ptr = dump_files[phase].flags;
return stream;
}
/* Returns non-zero if tree dump PHASE is enabled. */
int
dump_enabled_p (phase)
enum tree_dump_index phase;
{
return dump_files[phase].state;
}
/* Returns the switch name of PHASE. */
const char *
dump_flag_name (phase)
enum tree_dump_index phase;
{
return dump_files[phase].swtch;
}
/* Finish a tree dump for PHASE. STREAM is the stream created by
dump_begin. */
void
dump_end (phase, stream)
enum tree_dump_index phase ATTRIBUTE_UNUSED;
FILE *stream;
{
fclose (stream);
}
/* Parse ARG as a dump switch. Return non-zero if it is, and store the
relevant details in the dump_files array. */
int
dump_switch_p (arg)
const char *arg;
{
unsigned ix;
const char *option_value;
for (ix = 0; ix != TDI_end; ix++)
if ((option_value = skip_leading_substring (arg, dump_files[ix].swtch)))
{
const char *ptr = option_value;
int flags = 0;
while (*ptr)
{
const struct dump_option_value_info *option_ptr;
const char *end_ptr;
unsigned length;
while (*ptr == '-')
ptr++;
end_ptr = strchr (ptr, '-');
if (!end_ptr)
end_ptr = ptr + strlen (ptr);
length = end_ptr - ptr;
for (option_ptr = dump_options; option_ptr->name;
option_ptr++)
if (strlen (option_ptr->name) == length
&& !memcmp (option_ptr->name, ptr, length))
{
flags |= option_ptr->value;
goto found;
}
warning ("ignoring unknown option `%.*s' in `-f%s'",
length, ptr, dump_files[ix].swtch);
found:;
ptr = end_ptr;
}
dump_files[ix].state = -1;
dump_files[ix].flags = flags;
return 1;
}
return 0;
}

95
gcc/c-dump.h
View file

@ -1,95 +0,0 @@
/* 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 GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#ifndef GCC_C_DUMP_H
#define GCC_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. */
struct dump_info
{
/* The stream on which to dump the information. */
FILE *stream;
/* The original node. */
tree node;
/* User flags. */
int flags;
/* 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 the CHILD and its children. */
#define dump_child(field, child) \
queue_and_dump_index (di, field, child, DUMP_NONE)
extern void dump_pointer
PARAMS ((dump_info_p, const char *, void *));
extern void dump_int
PARAMS ((dump_info_p, const char *, int));
extern void dump_string
PARAMS ((dump_info_p, const char *));
extern void dump_stmt
PARAMS ((dump_info_p, tree));
extern void dump_next_stmt
PARAMS ((dump_info_p, tree));
extern void queue_and_dump_index
PARAMS ((dump_info_p, const char *, tree, int));
extern void queue_and_dump_type
PARAMS ((dump_info_p, tree));
#endif /* ! GCC_C_DUMP_H */

14
gcc/cp/ChangeLog
View file

@ -1,3 +1,17 @@
2001-11-22 Bryce McKinlay <bryce@waitaki.otago.ac.nz>
* cp-tree.h (CP_TYPE_QUALS): Removed.
* decl.c (cxx_init_decl_processing): Don't set lang_dump_tree.
* cp-lang.c: Set LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN and
LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN.
* dump.c (cp_dump_tree): Use void* dump_info argument to match
lang-hooks prototype.
* call.c, cp-tree.h, cvt.c, decl.c, init.c, mangle.c, method.c, pt.c,
rtti.c, semantics.c, tree.c, typeck.c, typeck2.c: All references to
CP_TYPE_QUALS changed to cp_type_quals.
* Make-lang.in: References to c-dump.h changed to tree-dump.h.
(CXX_C_OBJS): Remove c-dump.o.
2001-11-21 Mark Mitchell <mark@codesourcery.com>
PR c++/3637

4
gcc/cp/Make-lang.in
View file

@ -96,7 +96,7 @@ $(DEMANGLER_PROG): cxxmain.o underscore.o $(LIBDEPS)
# The compiler itself.
# Shared with C front end:
CXX_C_OBJS = attribs.o c-common.o c-format.o c-pragma.o c-semantics.o c-lex.o \
c-dump.o $(CXX_TARGET_OBJS)
$(CXX_TARGET_OBJS)
# Language-specific object files.
CXX_OBJS = cp/call.o cp/decl.o cp/expr.o cp/pt.o cp/typeck2.o \
@ -279,7 +279,7 @@ cp/repo.o: cp/repo.c $(CXX_TREE_H) toplev.h $(GGC_H) diagnostic.h
cp/semantics.o: cp/semantics.c $(CXX_TREE_H) cp/lex.h except.h toplev.h \
flags.h $(GGC_H) debug.h output.h $(RTL_H) $(TIMEVAR_H) $(EXPR_H) \
tree-inline.h
cp/dump.o: cp/dump.c $(CXX_TREE_H) c-dump.h
cp/dump.o: cp/dump.c $(CXX_TREE_H) tree-dump.h
cp/optimize.o: cp/optimize.c $(CXX_TREE_H) rtl.h integrate.h insn-config.h \
input.h $(PARAMS_H) debug.h tree-inline.h
cp/mangle.o: cp/mangle.c $(CXX_TREE_H) toplev.h

8
gcc/cp/call.c
View file

@ -777,7 +777,7 @@ standard_conversion (to, from, expr)
{
from = build_pointer_type
(cp_build_qualified_type (void_type_node,
CP_TYPE_QUALS (TREE_TYPE (from))));
cp_type_quals (TREE_TYPE (from))));
conv = build_conv (PTR_CONV, from, conv);
}
else if (ufcode == OFFSET_TYPE && utcode == OFFSET_TYPE)
@ -803,7 +803,7 @@ standard_conversion (to, from, expr)
{
from =
cp_build_qualified_type (TREE_TYPE (to),
CP_TYPE_QUALS (TREE_TYPE (from)));
cp_type_quals (TREE_TYPE (from)));
from = build_pointer_type (from);
conv = build_conv (PTR_CONV, from, conv);
}
@ -838,10 +838,10 @@ standard_conversion (to, from, expr)
|| !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
|| !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
|| CP_TYPE_QUALS (fbase) != CP_TYPE_QUALS (tbase))
|| cp_type_quals (fbase) != cp_type_quals (tbase))
return 0;
from = cp_build_qualified_type (tbase, CP_TYPE_QUALS (fbase));
from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
from = build_cplus_method_type (from, TREE_TYPE (fromfn),
TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
from = build_ptrmemfunc_type (build_pointer_type (from));

4
gcc/cp/cp-lang.c
View file

@ -78,6 +78,10 @@ static HOST_WIDE_INT cxx_get_alias_set PARAMS ((tree));
cp_copy_res_decl_for_inlining
#undef LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P
#define LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P anon_aggr_type_p
#undef LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN
#define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN cp_dump_tree
#undef LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN
#define LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN cp_type_quals
/* Each front end provides its own hooks, for toplev.c. */
const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;

14
gcc/cp/cp-tree.h
View file

@ -1128,28 +1128,24 @@ enum languages { lang_c, lang_cplusplus, lang_java };
/* True if this a "Java" type, defined in 'extern "Java"'. */
#define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3(NODE)
/* The type qualifiers for this type, including the qualifiers on the
elements for an array type. */
#define CP_TYPE_QUALS(NODE) C_TYPE_QUALS (NODE)
/* Nonzero if this type is const-qualified. */
#define CP_TYPE_CONST_P(NODE) \
((CP_TYPE_QUALS (NODE) & TYPE_QUAL_CONST) != 0)
((cp_type_quals (NODE) & TYPE_QUAL_CONST) != 0)
/* Nonzero if this type is volatile-qualified. */
#define CP_TYPE_VOLATILE_P(NODE) \
((CP_TYPE_QUALS (NODE) & TYPE_QUAL_VOLATILE) != 0)
((cp_type_quals (NODE) & TYPE_QUAL_VOLATILE) != 0)
/* Nonzero if this type is restrict-qualified. */
#define CP_TYPE_RESTRICT_P(NODE) \
((CP_TYPE_QUALS (NODE) & TYPE_QUAL_RESTRICT) != 0)
((cp_type_quals (NODE) & TYPE_QUAL_RESTRICT) != 0)
/* Nonzero if this type is const-qualified, but not
volatile-qualified. Other qualifiers are ignored. This macro is
used to test whether or not it is OK to bind an rvalue to a
reference. */
#define CP_TYPE_CONST_NON_VOLATILE_P(NODE) \
((CP_TYPE_QUALS (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \
((cp_type_quals (NODE) & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)) \
== TYPE_QUAL_CONST)
#define FUNCTION_ARG_CHAIN(NODE) \
@ -4341,7 +4337,7 @@ extern tree mangle_guard_variable PARAMS ((tree));
extern tree mangle_ref_init_variable PARAMS ((tree));
/* in dump.c */
extern int cp_dump_tree PARAMS ((dump_info_p, tree));
extern int cp_dump_tree PARAMS ((void *, tree));
/* -- end of C++ */

4
gcc/cp/cvt.c
View file

@ -657,7 +657,7 @@ convert_pointer_to_real (binfo, expr)
}
ptr_type = cp_build_qualified_type (type,
CP_TYPE_QUALS (TREE_TYPE (intype)));
cp_type_quals (TREE_TYPE (intype)));
ptr_type = build_pointer_type (ptr_type);
if (same_type_p (ptr_type, TYPE_MAIN_VARIANT (intype)))
return expr;
@ -1267,7 +1267,7 @@ type_promotes_to (type)
if (type == error_mark_node)
return error_mark_node;
type_quals = CP_TYPE_QUALS (type);
type_quals = cp_type_quals (type);
type = TYPE_MAIN_VARIANT (type);
/* bool always promotes to int (not unsigned), even if it's the same

17
gcc/cp/decl.c
View file

@ -6408,7 +6408,6 @@ cxx_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;
lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
cp_parse_init ();
@ -9206,7 +9205,7 @@ build_ptrmemfunc_type (type)
/* Make sure that we always have the unqualified pointer-to-member
type first. */
if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
if (cp_type_quals (type) != TYPE_UNQUALIFIED)
unqualified_variant
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
@ -9229,9 +9228,9 @@ build_ptrmemfunc_type (type)
type, set the TYPE_MAIN_VARIANT for this type to be the
unqualified type. Since they are actually RECORD_TYPEs that are
not variants of each other, we must do this manually. */
if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
if (cp_type_quals (type) != TYPE_UNQUALIFIED)
{
t = build_qualified_type (t, CP_TYPE_QUALS (type));
t = build_qualified_type (t, cp_type_quals (type));
TYPE_MAIN_VARIANT (t) = unqualified_variant;
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
TYPE_NEXT_VARIANT (unqualified_variant) = t;
@ -10159,7 +10158,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
{
RIDBIT_RESET (RID_LONG, specbits);
type = build_qualified_type (long_double_type_node,
CP_TYPE_QUALS (type));
cp_type_quals (type));
}
/* Check all other uses of type modifiers. */
@ -11129,7 +11128,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
&& TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& TYPE_ANONYMOUS_P (type)
&& CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
&& cp_type_quals (type) == TYPE_UNQUALIFIED)
{
tree oldname = TYPE_NAME (type);
tree t;
@ -13539,7 +13538,7 @@ start_function (declspecs, declarator, attrs, flags)
{
DECL_RESULT (decl1)
= build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
c_apply_type_quals_to_decl (cp_type_quals (restype),
DECL_RESULT (decl1));
}
}
@ -14469,14 +14468,14 @@ revert_static_member_fn (decl)
tree function = TREE_TYPE (decl);
tree args = TYPE_ARG_TYPES (function);
if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
!= TYPE_UNQUALIFIED)
cp_error ("static member function `%#D' declared with type qualifiers",
decl);
args = TREE_CHAIN (args);
tmp = build_function_type (TREE_TYPE (function), args);
tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
tmp = build_qualified_type (tmp, cp_type_quals (function));
tmp = build_exception_variant (tmp,
TYPE_RAISES_EXCEPTIONS (function));
TREE_TYPE (decl) = tmp;

7
gcc/cp/dump.c
View file

@ -23,7 +23,7 @@ Boston, MA 02111-1307, USA. */
#include "system.h"
#include "tree.h"
#include "cp-tree.h"
#include "c-dump.h"
#include "tree-dump.h"
static void dump_access
PARAMS ((dump_info_p, tree));
@ -208,11 +208,12 @@ dump_op (di, t)
}
int
cp_dump_tree (di, t)
dump_info_p di;
cp_dump_tree (dump_info, t)
void *dump_info;
tree t;
{
enum tree_code code;
dump_info_p di = (dump_info_p) dump_info;
/* Figure out what kind of node this is. */
code = TREE_CODE (t);

2
gcc/cp/init.c
View file

@ -1177,7 +1177,7 @@ build_aggr_init (exp, init, flags)
cp_error ("bad array initializer");
return error_mark_node;
}
if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
if (cp_type_quals (type) != TYPE_UNQUALIFIED)
{
TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
if (init)

4
gcc/cp/mangle.c
View file

@ -509,7 +509,7 @@ find_substitution (node)
std::basic_string <char,
std::char_traits<char>,
std::allocator<char> > . */
if (CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED
if (cp_type_quals (type) == TYPE_UNQUALIFIED
&& CLASSTYPE_USE_TEMPLATE (type))
{
tree args = CLASSTYPE_TI_ARGS (type);
@ -535,7 +535,7 @@ find_substitution (node)
/* Check for basic_{i,o,io}stream. */
if (TYPE_P (node)
&& CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED
&& cp_type_quals (type) == TYPE_UNQUALIFIED
&& CLASS_TYPE_P (type)
&& CLASSTYPE_USE_TEMPLATE (type)
&& CLASSTYPE_TEMPLATE_INFO (type) != NULL)

6
gcc/cp/method.c
View file

@ -551,7 +551,7 @@ do_build_copy_constructor (fndecl)
tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
tree member_init_list = NULL_TREE;
tree base_init_list = NULL_TREE;
int cvquals = CP_TYPE_QUALS (TREE_TYPE (parm));
int cvquals = cp_type_quals (TREE_TYPE (parm));
int i;
/* Initialize all the base-classes with the parameter converted to
@ -640,7 +640,7 @@ do_build_assign_ref (fndecl)
tree fields = TYPE_FIELDS (current_class_type);
int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type);
tree binfos = TYPE_BINFO_BASETYPES (current_class_type);
int cvquals = CP_TYPE_QUALS (TREE_TYPE (parm));
int cvquals = cp_type_quals (TREE_TYPE (parm));
int i;
for (i = 0; i < n_bases; ++i)
@ -919,7 +919,7 @@ locate_copy (type, client_)
continue;
if (!sufficient_parms_p (TREE_CHAIN (parms)))
continue;
quals = CP_TYPE_QUALS (src_type);
quals = cp_type_quals (src_type);
if (client->quals & ~quals)
continue;
excess = quals & ~client->quals;

20
gcc/cp/pt.c
View file

@ -5905,7 +5905,7 @@ tsubst_decl (t, args, type)
{
r = copy_node (t);
TREE_TYPE (r) = type;
c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
c_apply_type_quals_to_decl (cp_type_quals (type), r);
if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
DECL_INITIAL (r) = TREE_TYPE (r);
@ -5928,7 +5928,7 @@ tsubst_decl (t, args, type)
{
r = copy_decl (t);
TREE_TYPE (r) = type;
c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
c_apply_type_quals_to_decl (cp_type_quals (type), r);
/* We don't have to set DECL_CONTEXT here; it is set by
finish_member_declaration. */
@ -6007,7 +6007,7 @@ tsubst_decl (t, args, type)
r = copy_decl (t);
TREE_TYPE (r) = type;
c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
c_apply_type_quals_to_decl (cp_type_quals (type), r);
DECL_CONTEXT (r) = ctx;
/* Clear out the mangled name and RTL for the instantiation. */
SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
@ -6394,7 +6394,7 @@ tsubst (t, args, complain, in_decl)
{
my_friendly_assert (TYPE_P (arg), 0);
return cp_build_qualified_type_real
(arg, CP_TYPE_QUALS (arg) | CP_TYPE_QUALS (t),
(arg, cp_type_quals (arg) | cp_type_quals (t),
complain);
}
else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
@ -6445,10 +6445,10 @@ tsubst (t, args, complain, in_decl)
case TEMPLATE_TYPE_PARM:
case TEMPLATE_TEMPLATE_PARM:
case BOUND_TEMPLATE_TEMPLATE_PARM:
if (CP_TYPE_QUALS (t))
if (cp_type_quals (t))
{
r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
r = cp_build_qualified_type_real (r, CP_TYPE_QUALS (t),
r = cp_build_qualified_type_real (r, cp_type_quals (t),
complain);
}
else
@ -6755,8 +6755,8 @@ tsubst (t, args, complain, in_decl)
if (f == error_mark_node)
return f;
return cp_build_qualified_type_real (f,
CP_TYPE_QUALS (f)
| CP_TYPE_QUALS (t),
cp_type_quals (f)
| cp_type_quals (t),
complain);
}
@ -8667,8 +8667,8 @@ unify (tparms, targs, parm, arg, strict)
PARM is `const T'. Then, T should be `volatile int'. */
arg =
cp_build_qualified_type_real (arg,
CP_TYPE_QUALS (arg)
& ~CP_TYPE_QUALS (parm),
cp_type_quals (arg)
& ~cp_type_quals (parm),
/*complain=*/0);
if (arg == error_mark_node)
return 1;

6
gcc/cp/rtti.c
View file

@ -107,7 +107,7 @@ build_headof (exp)
offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
type = build_qualified_type (ptr_type_node,
CP_TYPE_QUALS (TREE_TYPE (exp)));
cp_type_quals (TREE_TYPE (exp)));
return build (PLUS_EXPR, type, exp,
cp_convert (ptrdiff_type_node, offset));
}
@ -923,8 +923,8 @@ typeinfo_in_lib_p (type)
/* The typeinfo objects for `T*' and `const T*' are in the runtime
library for simple types T. */
if (TREE_CODE (type) == POINTER_TYPE
&& (CP_TYPE_QUALS (TREE_TYPE (type)) == TYPE_QUAL_CONST
|| CP_TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
&& (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
|| cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
type = TREE_TYPE (type);
switch (TREE_CODE (type))

2
gcc/cp/semantics.c
View file

@ -2128,7 +2128,7 @@ finish_base_specifier (access_specifier, base_class)
result = NULL_TREE;
else
{
if (CP_TYPE_QUALS (base_class) != 0)
if (cp_type_quals (base_class) != 0)
{
cp_error ("base class `%T' has cv qualifiers", base_class);
base_class = TYPE_MAIN_VARIANT (base_class);

6
gcc/cp/tree.c
View file

@ -490,7 +490,7 @@ build_cplus_array_type (elt_type, index_type)
tree index_type;
{
tree t;
int type_quals = CP_TYPE_QUALS (elt_type);
int type_quals = cp_type_quals (elt_type);
if (type_quals != TYPE_UNQUALIFIED)
elt_type = cp_build_qualified_type (elt_type, TYPE_UNQUALIFIED);
@ -521,7 +521,7 @@ cp_build_qualified_type_real (type, type_quals, complain)
if (type == error_mark_node)
return type;
if (type_quals == CP_TYPE_QUALS (type))
if (type_quals == cp_type_quals (type))
return type;
/* A restrict-qualified pointer type must be a pointer (or reference)
@ -624,7 +624,7 @@ tree
canonical_type_variant (t)
tree t;
{
return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), CP_TYPE_QUALS (t));
return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), cp_type_quals (t));
}
/* Makes new binfos for the indirect bases under BINFO, and updates

37
gcc/cp/typeck.c
View file

@ -223,7 +223,7 @@ qualify_type_recursive (t1, t2)
else
b1 = NULL_TREE;
type_quals = (CP_TYPE_QUALS (tt1) | CP_TYPE_QUALS (tt2));
type_quals = (cp_type_quals (tt1) | cp_type_quals (tt2));
tgt = qualify_type_recursive (tt1, tt2);
tgt = cp_build_qualified_type (tgt, type_quals);
if (b1)
@ -486,8 +486,8 @@ composite_pointer_type (t1, t2, arg1, arg2, location)
t1 = TREE_TYPE (t1);
t2 = TREE_TYPE (t2);
result_type = cp_build_qualified_type (void_type_node,
(CP_TYPE_QUALS (t1)
| CP_TYPE_QUALS (t2)));
(cp_type_quals (t1)
| cp_type_quals (t2)));
result_type = build_pointer_type (result_type);
}
else
@ -617,7 +617,7 @@ common_type (t1, t2)
else
b1 = b2 = NULL_TREE;
type_quals = (CP_TYPE_QUALS (tt1) | CP_TYPE_QUALS (tt2));
type_quals = (cp_type_quals (tt1) | cp_type_quals (tt2));
tt1 = TYPE_MAIN_VARIANT (tt1);
tt2 = TYPE_MAIN_VARIANT (tt2);
@ -795,7 +795,7 @@ comp_except_types (a, b, exact)
return 1;
else if (!exact)
{
if (CP_TYPE_QUALS (a) || CP_TYPE_QUALS (b))
if (cp_type_quals (a) || cp_type_quals (b))
return 0;
if (TREE_CODE (a) == POINTER_TYPE
@ -803,7 +803,7 @@ comp_except_types (a, b, exact)
{
a = TREE_TYPE (a);
b = TREE_TYPE (b);
if (CP_TYPE_QUALS (a) || CP_TYPE_QUALS (b))
if (cp_type_quals (a) || cp_type_quals (b))
return 0;
}
@ -983,7 +983,7 @@ comptypes (t1, t2, strict)
return 0;
/* Qualifiers must match. */
if (CP_TYPE_QUALS (t1) != CP_TYPE_QUALS (t2))
if (cp_type_quals (t1) != cp_type_quals (t2))
return 0;
if (strict == COMPARE_STRICT
&& TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
@ -1327,8 +1327,8 @@ at_least_as_qualified_p (type1, type2)
tree type2;
{
/* All qualifiers for TYPE2 must also appear in TYPE1. */
return ((CP_TYPE_QUALS (type1) & CP_TYPE_QUALS (type2))
== CP_TYPE_QUALS (type2));
return ((cp_type_quals (type1) & cp_type_quals (type2))
== cp_type_quals (type2));
}
/* Returns 1 if TYPE1 is more qualified than TYPE2. */
@ -1338,7 +1338,7 @@ more_qualified_p (type1, type2)
tree type1;
tree type2;
{
return (CP_TYPE_QUALS (type1) != CP_TYPE_QUALS (type2)
return (cp_type_quals (type1) != cp_type_quals (type2)
&& at_least_as_qualified_p (type1, type2));
}
@ -1350,7 +1350,7 @@ comp_cv_qualification (type1, type2)
tree type1;
tree type2;
{
if (CP_TYPE_QUALS (type1) == CP_TYPE_QUALS (type2))
if (cp_type_quals (type1) == cp_type_quals (type2))
return 0;
if (at_least_as_qualified_p (type1, type2))
@ -2241,8 +2241,8 @@ build_component_ref (datum, component, basetype_path, protect)
;
else
{
type_quals = (CP_TYPE_QUALS (field_type)
| CP_TYPE_QUALS (TREE_TYPE (datum)));
type_quals = (cp_type_quals (field_type)
| cp_type_quals (TREE_TYPE (datum)));
/* A field is const (volatile) if the enclosing object, or the
field itself, is const (volatile). But, a mutable field is
@ -6892,7 +6892,8 @@ comp_ptr_ttypes_reinterpret (to, from)
}
}
/* Returns the type-qualifier set corresponding to TYPE. */
/* Returns the type qualifiers for this type, including the qualifiers on the
elements for an array type. */
int
cp_type_quals (type)
@ -6958,14 +6959,14 @@ casts_away_constness_r (t1, t2)
|| TREE_CODE (*t2) != POINTER_TYPE)
{
*t1 = cp_build_qualified_type (void_type_node,
CP_TYPE_QUALS (*t1));
cp_type_quals (*t1));
*t2 = cp_build_qualified_type (void_type_node,
CP_TYPE_QUALS (*t2));
cp_type_quals (*t2));
return;
}
quals1 = CP_TYPE_QUALS (*t1);
quals2 = CP_TYPE_QUALS (*t2);
quals1 = cp_type_quals (*t1);
quals2 = cp_type_quals (*t2);
*t1 = TREE_TYPE (*t1);
*t2 = TREE_TYPE (*t2);
casts_away_constness_r (t1, t2);

4
gcc/cp/typeck2.c
View file

@ -1159,8 +1159,8 @@ build_m_component_ref (datum, component)
;
else
{
type_quals = (CP_TYPE_QUALS (field_type)
| CP_TYPE_QUALS (TREE_TYPE (datum)));
type_quals = (cp_type_quals (field_type)
| cp_type_quals (TREE_TYPE (datum)));
/* There's no such thing as a mutable pointer-to-member, so we don't
need to deal with that here like we do in build_component_ref. */

17
gcc/langhooks-def.h
View file

@ -103,7 +103,19 @@ int lhd_tree_inlining_anon_aggr_type_p PARAMS ((tree));
LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P \
} \
/* The whole thing. The structure is defined in toplev.h. */
/* Tree dump hooks. */
int lhd_tree_dump_dump_tree PARAMS ((void *, tree));
int lhd_tree_dump_type_quals PARAMS ((tree));
#define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN lhd_tree_dump_dump_tree
#define LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN lhd_tree_dump_type_quals
#define LANG_HOOKS_TREE_DUMP_INITIALIZER { \
LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN, \
LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN \
} \
/* The whole thing. The structure is defined in langhooks.h. */
#define LANG_HOOKS_INITIALIZER { \
LANG_HOOKS_NAME, \
LANG_HOOKS_IDENTIFIER_SIZE, \
@ -121,7 +133,8 @@ int lhd_tree_inlining_anon_aggr_type_p PARAMS ((tree));
LANG_HOOKS_PRINT_TYPE, \
LANG_HOOKS_PRINT_IDENTIFIER, \
LANG_HOOKS_SET_YYDEBUG, \
LANG_HOOKS_TREE_INLINING_INITIALIZER \
LANG_HOOKS_TREE_INLINING_INITIALIZER, \
LANG_HOOKS_TREE_DUMP_INITIALIZER \
}
#endif /* GCC_LANG_HOOKS_DEF_H */

23
gcc/langhooks.c
View file

@ -23,6 +23,7 @@ Boston, MA 02111-1307, USA. */
#include "system.h"
#include "toplev.h"
#include "tree.h"
#include "c-tree.h"
#include "tree-inline.h"
#include "rtl.h"
#include "insn-config.h"
@ -211,3 +212,25 @@ lhd_tree_inlining_anon_aggr_type_p (t)
return 0;
}
/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree
nodes. Returns non-zero if it does not want the usual dumping of the
second argument. */
int
lhd_tree_dump_dump_tree (di, t)
void *di ATTRIBUTE_UNUSED;
tree t ATTRIBUTE_UNUSED;
{
return 0;
}
/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
language-specific way. */
int
lhd_tree_dump_type_quals (t)
tree t;
{
return TYPE_QUALS (t);
}

16
gcc/langhooks.h
View file

@ -48,6 +48,18 @@ struct lang_hooks_for_tree_inlining
int (*anon_aggr_type_p) PARAMS ((union tree_node *));
};
/* The following hooks are used by tree-dump.c. */
struct lang_hooks_for_tree_dump
{
/* Dump language-specific parts of tree nodes. Returns non-zero if it
does not want the usual dumping of the second argument. */
int (*dump_tree) PARAMS ((void *, tree));
/* Determine type qualifiers in a language-specific way. */
int (*type_quals) PARAMS ((tree));
};
/* Language-specific hooks. See langhooks-def.h for defaults. */
struct lang_hooks
@ -116,8 +128,10 @@ struct lang_hooks
void (*set_yydebug) PARAMS ((int));
struct lang_hooks_for_tree_inlining tree_inlining;
struct lang_hooks_for_tree_dump tree_dump;
/* Whenever you add entries here, make sure you adjust langhooks.h
/* Whenever you add entries here, make sure you adjust langhooks-def.h
and langhooks.c accordingly. */
};

2
gcc/tree-dump.c
View file

@ -26,7 +26,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "splay-tree.h"
#include "diagnostic.h"
#include "toplev.h"
#include "c-dump.h"
#include "tree-dump.h"
#include "langhooks.h"
static unsigned int queue PARAMS ((dump_info_p, tree, int));

6
gcc/tree-dump.h
View file

@ -19,8 +19,8 @@ along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#ifndef GCC_C_DUMP_H
#define GCC_C_DUMP_H
#ifndef GCC_TREE_DUMP_H
#define GCC_TREE_DUMP_H
/* Flags used with queue functions. */
#define DUMP_NONE 0
@ -92,4 +92,4 @@ extern void queue_and_dump_index
extern void queue_and_dump_type
PARAMS ((dump_info_p, tree));
#endif /* ! GCC_C_DUMP_H */
#endif /* ! GCC_TREE_DUMP_H */

31
gcc/tree.h
View file

@ -3059,6 +3059,37 @@ extern void dwarf2out_return_reg PARAMS ((const char *, unsigned));
typedef tree (*walk_tree_fn) PARAMS ((tree *, int *, void *));
/* In tree-dump.c */
/* Different tree dump places. When you add new tree dump places,
extend the DUMP_FILES array in tree-dump.c */
enum tree_dump_index
{
TDI_all, /* dump the whole translation unit */
TDI_class, /* dump class hierarchy */
TDI_original, /* dump each function before optimizing it */
TDI_optimized, /* dump each function after optimizing it */
TDI_inlined, /* dump each function after inlining
within it. */
TDI_end
};
/* Bit masks to control tree dumping. Not all values are applicable to
all tree dumps. Add new ones at the end. When you define new
values, extend the DUMP_OPTIONS array in tree-dump.c */
#define TDF_ADDRESS (1 << 0) /* dump node addresses */
#define TDF_SLIM (1 << 1) /* don't go wild following links */
typedef struct dump_info *dump_info_p;
extern int dump_flag PARAMS ((dump_info_p, int, tree));
extern int dump_enabled_p PARAMS ((enum tree_dump_index));
extern FILE *dump_begin PARAMS ((enum tree_dump_index, int *));
extern void dump_end PARAMS ((enum tree_dump_index, FILE *));
extern void dump_node PARAMS ((tree, int, FILE *));
extern int dump_switch_p PARAMS ((const char *));
extern const char *dump_flag_name PARAMS ((enum tree_dump_index));
/* Redefine abort to report an internal error w/o coredump, and
reporting the location of the error in the source file. This logic