From 7806a559f589afcd37baf9a6140b60f86b528fd2 Mon Sep 17 00:00:00 2001 From: mmitchel Date: Wed, 6 Oct 1999 05:35:38 +0000 Subject: [PATCH] * dump.c (DUMP_CHILDREN): Remove. (DUMP_BINFO): Adjust. (struct dump_node_info): Remove dump_children_p. (queue_and_dump_type): Remove dump_children_p parameter. (queue): Don't set dump_children_p. (dump_child): Pass DUMP_NONE, instead of DUMP_CHILDREN, to queue_and_dump_index. (dequeue_and_dump): Unconditionally print children. Adjust calls to functions mentioned above. (dump_node): Pass DUMP_NONE, instead of DUMP_CHILDREN to queue. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@29837 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/cp/ChangeLog | 11 ++ gcc/cp/dump.c | 382 ++++++++++++++++++++----------------------------------- 2 files changed, 146 insertions(+), 247 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index ffd457d..c87e517 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,5 +1,16 @@ 1999-10-05 Mark Mitchell + * dump.c (DUMP_CHILDREN): Remove. + (DUMP_BINFO): Adjust. + (struct dump_node_info): Remove dump_children_p. + (queue_and_dump_type): Remove dump_children_p parameter. + (queue): Don't set dump_children_p. + (dump_child): Pass DUMP_NONE, instead of DUMP_CHILDREN, to + queue_and_dump_index. + (dequeue_and_dump): Unconditionally print children. Adjust calls + to functions mentioned above. + (dump_node): Pass DUMP_NONE, instead of DUMP_CHILDREN to queue. + * ir.texi: Document BIND_EXPR, LOOP_EXPR, and EXIT_EXPR. * dump.c (dequeue_and_dump): Dump them. diff --git a/gcc/cp/dump.c b/gcc/cp/dump.c index f6e1539..2098d9b 100644 --- a/gcc/cp/dump.c +++ b/gcc/cp/dump.c @@ -27,8 +27,7 @@ Boston, MA 02111-1307, USA. */ /* Flags used with queue functions. */ #define DUMP_NONE 0 -#define DUMP_CHILDREN 1 -#define DUMP_BINFO 2 +#define DUMP_BINFO 1 /* Information about a node to be dumped. */ @@ -36,8 +35,6 @@ typedef struct dump_node_info { /* The index for the node. */ unsigned int index; - /* Nonzero if we should dump the children of the node. */ - unsigned int dump_children_p : 1; /* Nonzero if the node is a binfo. */ unsigned int binfo_p : 1; } *dump_node_info_p; @@ -78,7 +75,7 @@ typedef struct dump_info static unsigned int queue PROTO ((dump_info_p, tree, int)); static void dump_index PROTO ((dump_info_p, unsigned int)); static void queue_and_dump_index PROTO ((dump_info_p, const char *, tree, int)); -static void queue_and_dump_type PROTO ((dump_info_p, tree, int)); +static void queue_and_dump_type PROTO ((dump_info_p, tree)); static void dequeue_and_dump PROTO ((dump_info_p)); static void dump_new_line PROTO ((dump_info_p)); static void dump_maybe_newline PROTO ((dump_info_p)); @@ -89,9 +86,8 @@ static void dump_node PROTO ((tree, FILE *)); static void dump_stmt PROTO ((dump_info_p, tree)); static void dump_next_stmt PROTO ((dump_info_p, tree)); -/* Add T to the end of the queue of nodes to dump. If DUMP_CHILDREN_P - is non-zero, then its children should be dumped as well. Returns - the index assigned to T. */ +/* 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) @@ -118,7 +114,6 @@ queue (di, t, flags) /* Create a new entry in the splay-tree. */ dni = (dump_node_info_p) xmalloc (sizeof (struct dump_node_info)); dni->index = index; - dni->dump_children_p = ((flags & DUMP_CHILDREN) != 0); dni->binfo_p = ((flags & DUMP_BINFO) != 0); dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t, (splay_tree_value) dni); @@ -181,12 +176,11 @@ queue_and_dump_index (di, field, t, flags) /* Dump the type of T. */ static void -queue_and_dump_type (di, t, dump_children_p) +queue_and_dump_type (di, t) dump_info_p di; tree t; - int dump_children_p; { - queue_and_dump_index (di, "type", TREE_TYPE (t), dump_children_p); + queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE); } /* Insert a new line in the dump output, and indent to an appropriate @@ -273,7 +267,7 @@ dump_stmt (di, t) /* Dump the CHILD and its children. */ #define dump_child(field, child) \ - queue_and_dump_index (di, field, child, DUMP_CHILDREN) + queue_and_dump_index (di, field, child, DUMP_NONE) /* Dump the next statement after STMT. */ @@ -296,7 +290,6 @@ dequeue_and_dump (di) dump_node_info_p dni; tree t; unsigned int index; - int dump_children_p; enum tree_code code; char code_class; const char* code_name; @@ -307,7 +300,6 @@ dequeue_and_dump (di) t = (tree) stn->key; dni = (dump_node_info_p) stn->value; index = dni->index; - dump_children_p = dni->dump_children_p; /* Remove the node from the queue, and put it on the free list. */ di->queue = dq->next; @@ -343,11 +335,8 @@ dequeue_and_dump (di) if (TREE_VIA_VIRTUAL (t)) dump_string (di, "virt"); - if (dump_children_p) - { - dump_child ("type", BINFO_TYPE (t)); - dump_child ("base", BINFO_BASETYPES (t)); - } + dump_child ("type", BINFO_TYPE (t)); + dump_child ("base", BINFO_BASETYPES (t)); goto done; } @@ -357,29 +346,26 @@ dequeue_and_dump (di) if (IS_EXPR_CODE_CLASS (code_class)) { /* If we're dumping children, dump them now. */ - if (dump_children_p) - { - queue_and_dump_type (di, t, 1); + queue_and_dump_type (di, t); - switch (code_class) - { - case '1': - dump_child ("op 0", TREE_OPERAND (t, 0)); - break; + 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 '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; + case 'e': + /* These nodes are handled explicitly below. */ + break; - default: - my_friendly_abort (19990726); - } + default: + my_friendly_abort (19990726); } } else if (code_class == 'd') @@ -388,11 +374,8 @@ dequeue_and_dump (di) if (DECL_NAME (t)) dump_child ("name", DECL_NAME (t)); /* And types. */ - if (dump_children_p) - { - queue_and_dump_type (di, t, 1); - queue_and_dump_index (di, "scpe", DECL_CONTEXT (t), 0); - } + queue_and_dump_type (di, t); + queue_and_dump_index (di, "scpe", DECL_CONTEXT (t), 0); /* And a source position. */ if (DECL_SOURCE_FILE (t)) { @@ -430,22 +413,19 @@ dequeue_and_dump (di) /* All types have associated declarations. */ dump_child ("name", TYPE_NAME (t)); - if (dump_children_p) - { - /* All types have a main variant. */ - if (TYPE_MAIN_VARIANT (t) != t) - dump_child ("unql", TYPE_MAIN_VARIANT (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)); - } + /* And sizes. */ + dump_child ("size", TYPE_SIZE (t)); /* All types have alignments. */ dump_int (di, "algn", TYPE_ALIGN (t)); } - else if (code_class == 'c' && dump_children_p) + else if (code_class == 'c') /* All constants can have types. */ - queue_and_dump_type (di, t, 1); + queue_and_dump_type (di, t); /* Now handle the various kinds of nodes. */ switch (code) @@ -467,23 +447,19 @@ dequeue_and_dump (di) break; case TREE_LIST: - if (dump_children_p) - { - dump_child ("purp", TREE_PURPOSE (t)); - dump_child ("valu", TREE_VALUE (t)); - dump_child ("chan", TREE_CHAIN (t)); - } + 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", IDENTIFIER_LENGTH (t)); - if (dump_children_p) - for (i = 0; i < TREE_VEC_LENGTH (t); ++i) - { - char buffer[32]; - sprintf (buffer, "%u", i); - queue_and_dump_index (di, buffer, TREE_VEC_ELT (t, i), 1); - } + for (i = 0; i < TREE_VEC_LENGTH (t); ++i) + { + char buffer[32]; + sprintf (buffer, "%u", i); + queue_and_dump_index (di, buffer, TREE_VEC_ELT (t, i), 1); + } break; case INTEGER_TYPE: @@ -491,13 +467,10 @@ dequeue_and_dump (di) dump_int (di, "prec", TYPE_PRECISION (t)); if (TREE_UNSIGNED (t)) dump_string (di, "unsigned"); - if (dump_children_p) - { - dump_child ("min", TYPE_MIN_VALUE (t)); - dump_child ("max", TYPE_MAX_VALUE (t)); - } + dump_child ("min", TYPE_MIN_VALUE (t)); + dump_child ("max", TYPE_MAX_VALUE (t)); - if (code == ENUMERAL_TYPE && dump_children_p) + if (code == ENUMERAL_TYPE) dump_child ("csts", TYPE_VALUES (t)); break; @@ -506,45 +479,34 @@ dequeue_and_dump (di) break; case POINTER_TYPE: - if (dump_children_p) + if (TYPE_PTRMEM_P (t)) { - if (TYPE_PTRMEM_P (t)) - { - dump_string (di, "ptrmem"); - queue_and_dump_index (di, "ptd", - TYPE_PTRMEM_POINTED_TO_TYPE (t), 1); - queue_and_dump_index (di, "cls", - TYPE_PTRMEM_CLASS_TYPE (t), 1); - } - else - dump_child ("ptd", TREE_TYPE (t)); + dump_string (di, "ptrmem"); + queue_and_dump_index (di, "ptd", + TYPE_PTRMEM_POINTED_TO_TYPE (t), 1); + queue_and_dump_index (di, "cls", + TYPE_PTRMEM_CLASS_TYPE (t), 1); } + else + dump_child ("ptd", TREE_TYPE (t)); break; case REFERENCE_TYPE: - if (dump_children_p) - dump_child ("refd", TREE_TYPE (t)); + dump_child ("refd", TREE_TYPE (t)); break; case METHOD_TYPE: - if (dump_children_p) - dump_child ("clas", TYPE_METHOD_BASETYPE (t)); + dump_child ("clas", TYPE_METHOD_BASETYPE (t)); /* Fall through. */ case FUNCTION_TYPE: - if (dump_children_p) - { - dump_child ("retn", TREE_TYPE (t)); - dump_child ("prms", TYPE_ARG_TYPES (t)); - } + dump_child ("retn", TREE_TYPE (t)); + dump_child ("prms", TYPE_ARG_TYPES (t)); break; case ARRAY_TYPE: - if (dump_children_p) - { - dump_child ("elts", TREE_TYPE (t)); - dump_child ("domn", TYPE_DOMAIN (t)); - } + dump_child ("elts", TREE_TYPE (t)); + dump_child ("domn", TYPE_DOMAIN (t)); break; case RECORD_TYPE: @@ -566,36 +528,29 @@ dequeue_and_dump (di) else dump_string (di, "union"); - if (dump_children_p) - { - dump_child ("flds", TYPE_FIELDS (t)); - dump_child ("fncs", TYPE_METHODS (t)); - queue_and_dump_index (di, "binf", TYPE_BINFO (t), - DUMP_CHILDREN | DUMP_BINFO); - } + 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: - if (dump_children_p) - dump_child ("cnst", DECL_INITIAL (t)); + dump_child ("cnst", DECL_INITIAL (t)); break; case VAR_DECL: case PARM_DECL: case FIELD_DECL: case RESULT_DECL: - if (dump_children_p) - { - 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)); - } + 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 && dump_children_p) + if (TREE_CODE (t) == FIELD_DECL) { if (DECL_C_BIT_FIELD (t)) dump_string (di, "bitfield"); @@ -605,12 +560,9 @@ dequeue_and_dump (di) case FUNCTION_DECL: case THUNK_DECL: - if (dump_children_p) - { - queue_and_dump_index (di, "scpe", DECL_REAL_CONTEXT (t), 0); - dump_child ("mngl", DECL_ASSEMBLER_NAME (t)); - dump_child ("args", DECL_ARGUMENTS (t)); - } + queue_and_dump_index (di, "scpe", DECL_REAL_CONTEXT (t), 0); + dump_child ("mngl", DECL_ASSEMBLER_NAME (t)); + dump_child ("args", DECL_ARGUMENTS (t)); if (DECL_EXTERNAL (t)) dump_string (di, "undefined"); if (TREE_PUBLIC (t)) @@ -638,8 +590,7 @@ dequeue_and_dump (di) dump_int (di, "prio", GLOBAL_INIT_PRIORITY (t)); } - if (dump_children_p) - dump_child ("body", DECL_SAVED_TREE (t)); + dump_child ("body", DECL_SAVED_TREE (t)); } else { @@ -653,34 +604,26 @@ dequeue_and_dump (di) and therefore many other macros do not work on it. */ if (t == std_node) break; - if (dump_children_p) - dump_child ("dcls", cp_namespace_decls (t)); + dump_child ("dcls", cp_namespace_decls (t)); break; case TEMPLATE_DECL: - if (dump_children_p) - dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); + dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); break; case OVERLOAD: - if (dump_children_p) - { - dump_child ("crnt", OVL_CURRENT (t)); - dump_child ("chan", OVL_CHAIN (t)); - } + dump_child ("crnt", OVL_CURRENT (t)); + dump_child ("chan", OVL_CHAIN (t)); break; case ASM_STMT: dump_stmt (di, t); if (ASM_VOLATILE_P (t)) dump_string (di, "volatile"); - if (dump_children_p) - { - 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_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; @@ -693,140 +636,108 @@ dequeue_and_dump (di) case CASE_LABEL: /* Note that a case label is not like other statments; there is no way to get the line-number of a case label. */ - if (dump_children_p) - { - dump_child ("low", CASE_LOW (t)); - dump_child ("high", CASE_HIGH (t)); - } + 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); - if (dump_children_p) - dump_child ("body", COMPOUND_BODY (t)); + dump_child ("body", COMPOUND_BODY (t)); dump_next_stmt (di, t); break; case DECL_STMT: dump_stmt (di, t); - if (dump_children_p) - dump_child ("decl", DECL_STMT_DECL (t)); + dump_child ("decl", DECL_STMT_DECL (t)); dump_next_stmt (di, t); break; case DO_STMT: dump_stmt (di, t); - if (dump_children_p) - { - dump_child ("body", DO_BODY (t)); - dump_child ("cond", DO_COND (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); - if (dump_children_p) - dump_child ("expr", EXPR_STMT_EXPR (t)); + dump_child ("expr", EXPR_STMT_EXPR (t)); dump_next_stmt (di, t); break; case FOR_STMT: dump_stmt (di, t); - if (dump_children_p) - { - 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_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); - if (dump_children_p) - dump_child ("dest", GOTO_DESTINATION (t)); + dump_child ("dest", GOTO_DESTINATION (t)); dump_next_stmt (di, t); break; case IF_STMT: dump_stmt (di, t); - if (dump_children_p) - { - dump_child ("cond", IF_COND (t)); - dump_child ("then", THEN_CLAUSE (t)); - dump_child ("else", ELSE_CLAUSE (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); - if (dump_children_p) - dump_child ("labl", LABEL_STMT_LABEL (t)); + dump_child ("labl", LABEL_STMT_LABEL (t)); dump_next_stmt (di, t); break; case RETURN_STMT: dump_stmt (di, t); - if (dump_children_p) - dump_child ("expr", RETURN_EXPR (t)); + dump_child ("expr", RETURN_EXPR (t)); dump_next_stmt (di, t); break; case SWITCH_STMT: dump_stmt (di, t); - if (dump_children_p) - { - dump_child ("cond", SWITCH_COND (t)); - dump_child ("body", SWITCH_BODY (t)); - } + dump_child ("cond", SWITCH_COND (t)); + dump_child ("body", SWITCH_BODY (t)); dump_next_stmt (di, t); break; case TRY_BLOCK: dump_stmt (di, t); - if (dump_children_p) - { - dump_child ("body", TRY_STMTS (t)); - dump_child ("hdlr", TRY_HANDLERS (t)); - } + dump_child ("body", TRY_STMTS (t)); + dump_child ("hdlr", TRY_HANDLERS (t)); dump_next_stmt (di, t); break; case WHILE_STMT: dump_stmt (di, t); - if (dump_children_p) - { - dump_child ("cond", WHILE_COND (t)); - dump_child ("body", WHILE_BODY (t)); - } + dump_child ("cond", WHILE_COND (t)); + dump_child ("body", WHILE_BODY (t)); dump_next_stmt (di, t); break; case SUBOBJECT: dump_stmt (di, t); - if (dump_children_p) - dump_child ("clnp", TREE_OPERAND (t, 0)); + dump_child ("clnp", TREE_OPERAND (t, 0)); dump_next_stmt (di, t); break; case START_CATCH_STMT: dump_stmt (di, t); - if (dump_children_p) - queue_and_dump_type (di, TREE_TYPE (t), /*dump_children_p=*/1); + queue_and_dump_type (di, TREE_TYPE (t)); dump_next_stmt (di, t); break; case CLEANUP_STMT: dump_stmt (di, t); - if (dump_children_p) - { - dump_child ("decl", CLEANUP_DECL (t)); - dump_child ("expr", CLEANUP_EXPR (t)); - } + dump_child ("decl", CLEANUP_DECL (t)); + dump_child ("expr", CLEANUP_EXPR (t)); dump_next_stmt (di, t); break; @@ -853,11 +764,8 @@ dequeue_and_dump (di) break; case PTRMEM_CST: - if (dump_children_p) - { - dump_child ("clas", PTRMEM_CST_CLASS (t)); - dump_child ("mbr", PTRMEM_CST_MEMBER (t)); - } + dump_child ("clas", PTRMEM_CST_CLASS (t)); + dump_child ("mbr", PTRMEM_CST_MEMBER (t)); break; case TRUTH_NOT_EXPR: @@ -865,8 +773,7 @@ dequeue_and_dump (di) case INDIRECT_REF: case THROW_EXPR: /* These nodes are unary, but do not have code class `1'. */ - if (dump_children_p) - dump_child ("op 0", TREE_OPERAND (t, 0)); + dump_child ("op 0", TREE_OPERAND (t, 0)); break; case TRUTH_ANDIF_EXPR: @@ -878,71 +785,52 @@ dequeue_and_dump (di) case COND_EXPR: case ARRAY_REF: /* These nodes are binary, but do not have code class `2'. */ - if (dump_children_p) - { - dump_child ("op 0", TREE_OPERAND (t, 0)); - dump_child ("op 1", TREE_OPERAND (t, 1)); - } + dump_child ("op 0", TREE_OPERAND (t, 0)); + dump_child ("op 1", TREE_OPERAND (t, 1)); break; case CALL_EXPR: - if (dump_children_p) - { - dump_child ("fn", TREE_OPERAND (t, 0)); - dump_child ("args", TREE_OPERAND (t, 1)); - } + dump_child ("fn", TREE_OPERAND (t, 0)); + dump_child ("args", TREE_OPERAND (t, 1)); break; case CONSTRUCTOR: - if (dump_children_p) - dump_child ("elts", TREE_OPERAND (t, 1)); + dump_child ("elts", TREE_OPERAND (t, 1)); break; case STMT_EXPR: - if (dump_children_p) - dump_child ("stmt", STMT_EXPR_STMT (t)); + dump_child ("stmt", STMT_EXPR_STMT (t)); break; case BIND_EXPR: - if (dump_children_p) - { - dump_child ("vars", TREE_OPERAND (t, 0)); - dump_child ("body", TREE_OPERAND (t, 1)); - } + dump_child ("vars", TREE_OPERAND (t, 0)); + dump_child ("body", TREE_OPERAND (t, 1)); break; case LOOP_EXPR: - if (dump_children_p) - dump_child ("body", TREE_OPERAND (t, 0)); + dump_child ("body", TREE_OPERAND (t, 0)); break; case EXIT_EXPR: - if (dump_children_p) - dump_child ("cond", TREE_OPERAND (t, 0)); + dump_child ("cond", TREE_OPERAND (t, 0)); break; case TARGET_EXPR: - if (dump_children_p) - { - 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)); - } + dump_child ("decl", TREE_OPERAND (t, 0)); + dump_child ("init", TREE_OPERAND (t, 1)); + dump_child ("clnp", TREE_OPERAND (t, 2)); + /* There really are two possible places the initializer can be. + After RTL expansion, the second operand is moved to the + position of the fourth operand, and the second operand + becomes NULL. */ + dump_child ("init", TREE_OPERAND (t, 3)); break; case AGGR_INIT_EXPR: dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t)); - if (dump_children_p) - { - dump_child ("fn", TREE_OPERAND (t, 0)); - dump_child ("args", TREE_OPERAND (t, 1)); - dump_child ("decl", TREE_OPERAND (t, 2)); - } + dump_child ("fn", TREE_OPERAND (t, 0)); + dump_child ("args", TREE_OPERAND (t, 1)); + dump_child ("decl", TREE_OPERAND (t, 2)); break; default: @@ -977,7 +865,7 @@ dump_node (t, stream) (splay_tree_delete_value_fn) &free); /* Queue up the first node. */ - queue (&di, t, DUMP_CHILDREN); + queue (&di, t, DUMP_NONE); /* Until the queue is empty, keep dumping nodes. */ while (di.queue) -- 2.7.4