* 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
+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.
# 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.
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
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 = \
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 \
#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) \
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
+++ /dev/null
-/* Tree-dumping functionality for intermediate representation.
- Copyright (C) 1999, 2000 Free Software Foundation, Inc.
- Written by Mark Mitchell <mark@codesourcery.com>
-
-This file is part of 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;
-}
+++ /dev/null
-/* Tree-dumping functionality for intermediate representation.
- Copyright (C) 1999, 2000 Free Software Foundation, Inc.
- Written by Mark Mitchell <mark@codesourcery.com>
-
-This file is part of 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 */
+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
# 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 \
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
{
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)
{
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);
}
|| !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));
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;
/* 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) \
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++ */
}
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;
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
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 ();
/* 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));
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;
{
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. */
&& 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;
{
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));
}
}
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;
#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));
}
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);
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)
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);
/* 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)
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
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)
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;
{
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);
{
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. */
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);
{
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)
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
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);
}
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;
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));
}
/* 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))
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);
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);
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)
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));
}
\f
/* Makes new binfos for the indirect bases under BINFO, and updates
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)
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
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);
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
{
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;
}
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))
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. */
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));
}
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))
;
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
}
}
-/* 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)
|| 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);
;
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. */
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, \
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 */
#include "system.h"
#include "toplev.h"
#include "tree.h"
+#include "c-tree.h"
#include "tree-inline.h"
#include "rtl.h"
#include "insn-config.h"
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);
+}
+
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
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. */
};
#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));
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
extern void queue_and_dump_type
PARAMS ((dump_info_p, tree));
-#endif /* ! GCC_C_DUMP_H */
+#endif /* ! GCC_TREE_DUMP_H */
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));
+
\f
/* Redefine abort to report an internal error w/o coredump, and
reporting the location of the error in the source file. This logic
projects / thirdparty / gcc.git / commitdiff
