[gcc.git] / gcc / cp / dump.c

/* Tree-dumping functionality for intermediate representation.
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
   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 3, 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 COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "cp-tree.h"
#include "tree-dump.h"

static void dump_access (dump_info_p, tree);

static void dump_op (dump_info_p, tree);

/* Dump a representation of the accessibility information associated
   with T.  */

static void
dump_access (dump_info_p di, tree t)
{
  if (TREE_PROTECTED(t))
    dump_string_field (di, "accs", "prot");
  else if (TREE_PRIVATE(t))
    dump_string_field (di, "accs", "priv");
  else
    dump_string_field (di, "accs", "pub");
}

/* Dump a representation of the specific operator for an overloaded
   operator associated with node t.  */

static void
dump_op (dump_info_p di, tree t)
{
  switch (DECL_OVERLOADED_OPERATOR_P (t)) {
    case NEW_EXPR:
      dump_string (di, "new");
      break;
    case VEC_NEW_EXPR:
      dump_string (di, "vecnew");
      break;
    case DELETE_EXPR:
      dump_string (di, "delete");
      break;
    case VEC_DELETE_EXPR:
      dump_string (di, "vecdelete");
      break;
    case UNARY_PLUS_EXPR:
      dump_string (di, "pos");
      break;
    case NEGATE_EXPR:
      dump_string (di, "neg");
      break;
    case ADDR_EXPR:
      dump_string (di, "addr");
      break;
    case INDIRECT_REF:
      dump_string(di, "deref");
      break;
    case BIT_NOT_EXPR:
      dump_string(di, "not");
      break;
    case TRUTH_NOT_EXPR:
      dump_string(di, "lnot");
      break;
    case PREINCREMENT_EXPR:
      dump_string(di, "preinc");
      break;
    case PREDECREMENT_EXPR:
      dump_string(di, "predec");
      break;
    case PLUS_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "plusassign");
      else
	dump_string(di, "plus");
      break;
    case MINUS_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "minusassign");
      else
	dump_string(di, "minus");
      break;
    case MULT_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "multassign");
      else
	dump_string (di, "mult");
      break;
    case TRUNC_DIV_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "divassign");
      else
	dump_string (di, "div");
      break;
    case TRUNC_MOD_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	 dump_string (di, "modassign");
      else
	dump_string (di, "mod");
      break;
    case BIT_AND_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "andassign");
      else
	dump_string (di, "and");
      break;
    case BIT_IOR_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "orassign");
      else
	dump_string (di, "or");
      break;
    case BIT_XOR_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "xorassign");
      else
	dump_string (di, "xor");
      break;
    case LSHIFT_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "lshiftassign");
      else
	dump_string (di, "lshift");
      break;
    case RSHIFT_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "rshiftassign");
      else
	dump_string (di, "rshift");
      break;
    case EQ_EXPR:
      dump_string (di, "eq");
      break;
    case NE_EXPR:
      dump_string (di, "ne");
      break;
    case LT_EXPR:
      dump_string (di, "lt");
      break;
    case GT_EXPR:
      dump_string (di, "gt");
      break;
    case LE_EXPR:
      dump_string (di, "le");
      break;
    case GE_EXPR:
      dump_string (di, "ge");
      break;
    case TRUTH_ANDIF_EXPR:
      dump_string (di, "land");
      break;
    case TRUTH_ORIF_EXPR:
      dump_string (di, "lor");
      break;
    case COMPOUND_EXPR:
      dump_string (di, "compound");
      break;
    case MEMBER_REF:
      dump_string (di, "memref");
      break;
    case COMPONENT_REF:
      dump_string (di, "ref");
      break;
    case ARRAY_REF:
      dump_string (di, "subs");
      break;
    case POSTINCREMENT_EXPR:
      dump_string (di, "postinc");
      break;
    case POSTDECREMENT_EXPR:
      dump_string (di, "postdec");
      break;
    case CALL_EXPR:
      dump_string (di, "call");
      break;
    case NOP_EXPR:
      if (DECL_ASSIGNMENT_OPERATOR_P (t))
	dump_string (di, "assign");
      break;
    default:
      break;
  }
}

bool
cp_dump_tree (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);

  if (DECL_P (t))
    {
      if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
	dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
    }

  switch (code)
    {
    case IDENTIFIER_NODE:
      if (IDENTIFIER_OPNAME_P (t))
	{
	  dump_string_field (di, "note", "operator");
	  return true;
	}
      else if (IDENTIFIER_TYPENAME_P (t))
	{
	  dump_child ("tynm", TREE_TYPE (t));
	  return true;
	}
      break;

    case OFFSET_TYPE:
      dump_string_field (di, "note", "ptrmem");
      dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
      dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
      return true;

    case RECORD_TYPE:
      if (TYPE_PTRMEMFUNC_P (t))
	{
	  dump_string_field (di, "note", "ptrmem");
	  dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
	  dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
	  return true;
	}
      /* Fall through.  */

    case UNION_TYPE:
      /* Is it a type used as a base? */
      if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
	  && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
	{
	  dump_child ("bfld", TYPE_CONTEXT (t));
	  return true;
	}

      if (! MAYBE_CLASS_TYPE_P (t))
	break;

      dump_child ("vfld", TYPE_VFIELD (t));
      if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
	dump_string(di, "spec");

      if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
	{
	  int i;
	  tree binfo;
	  tree base_binfo;

	  for (binfo = TYPE_BINFO (t), i = 0;
	       BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
	    {
	      dump_child ("base", BINFO_TYPE (base_binfo));
	      if (BINFO_VIRTUAL_P (base_binfo))
		dump_string_field (di, "spec", "virt");
	      dump_access (di, base_binfo);
	    }
	}
      break;

    case FIELD_DECL:
      dump_access (di, t);
      if (DECL_MUTABLE_P (t))
	dump_string_field (di, "spec", "mutable");
      break;

    case VAR_DECL:
      if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
	dump_access (di, t);
      if (TREE_STATIC (t) && !TREE_PUBLIC (t))
	dump_string_field (di, "link", "static");
      break;

    case FUNCTION_DECL:
      if (!DECL_THUNK_P (t))
	{
	  if (DECL_OVERLOADED_OPERATOR_P (t)) {
	    dump_string_field (di, "note", "operator");
	    dump_op (di, t);
	  }
	  if (DECL_FUNCTION_MEMBER_P (t))
	    {
	      dump_string_field (di, "note", "member");
	      dump_access (di, t);
	    }
	  if (DECL_PURE_VIRTUAL_P (t))
	    dump_string_field (di, "spec", "pure");
	  if (DECL_VIRTUAL_P (t))
	    dump_string_field (di, "spec", "virt");
	  if (DECL_CONSTRUCTOR_P (t))
	    dump_string_field (di, "note", "constructor");
	  if (DECL_DESTRUCTOR_P (t))
	    dump_string_field (di, "note", "destructor");
	  if (DECL_CONV_FN_P (t))
	    dump_string_field (di, "note", "conversion");
	  if (DECL_GLOBAL_CTOR_P (t))
	    dump_string_field (di, "note", "global init");
	  if (DECL_GLOBAL_DTOR_P (t))
	    dump_string_field (di, "note", "global fini");
	  if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
	    dump_string_field (di, "note", "pseudo tmpl");
	}
      else
	{
	  tree virt = THUNK_VIRTUAL_OFFSET (t);

	  dump_string_field (di, "note", "thunk");
	  if (DECL_THIS_THUNK_P (t))
	    dump_string_field (di, "note", "this adjusting");
	  else
	    {
	      dump_string_field (di, "note", "result adjusting");
	      if (virt)
		virt = BINFO_VPTR_FIELD (virt);
	    }
	  dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
	  if (virt)
	    dump_int (di, "virt", tree_low_cst (virt, 0));
	  dump_child ("fn", DECL_INITIAL (t));
	}
      break;

    case NAMESPACE_DECL:
      if (DECL_NAMESPACE_ALIAS (t))
	dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
      else if (!dump_flag (di, TDF_SLIM, t))
	dump_child ("dcls", cp_namespace_decls (t));
      break;

    case TEMPLATE_DECL:
      dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
      dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
      dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
      dump_child ("prms", DECL_TEMPLATE_PARMS (t));
      break;

    case OVERLOAD:
      dump_child ("crnt", OVL_CURRENT (t));
      dump_child ("chan", OVL_CHAIN (t));
      break;

    case TRY_BLOCK:
      dump_stmt (di, t);
      if (CLEANUP_P (t))
	dump_string_field (di, "note", "cleanup");
      dump_child ("body", TRY_STMTS (t));
      dump_child ("hdlr", TRY_HANDLERS (t));
      break;

    case EH_SPEC_BLOCK:
      dump_stmt (di, t);
      dump_child ("body", EH_SPEC_STMTS (t));
      dump_child ("raises", EH_SPEC_RAISES (t));
      break;

    case PTRMEM_CST:
      dump_child ("clas", PTRMEM_CST_CLASS (t));
      dump_child ("mbr", PTRMEM_CST_MEMBER (t));
      break;

    case THROW_EXPR:
      /* These nodes are unary, but do not have code class `1'.  */
      dump_child ("op 0", TREE_OPERAND (t, 0));
      break;

    case AGGR_INIT_EXPR:
      {
	int i = 0;
	tree arg;
	aggr_init_expr_arg_iterator iter;
	dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
	dump_child ("fn", AGGR_INIT_EXPR_FN (t));
	FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
	  {
	    char buffer[32];
	    sprintf (buffer, "%u", i);
	    dump_child (buffer, arg);
	    i++;
	  }
	dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
      }
      break;

    case HANDLER:
      dump_stmt (di, t);
      dump_child ("parm", HANDLER_PARMS (t));
      dump_child ("body", HANDLER_BODY (t));
      break;

    case MUST_NOT_THROW_EXPR:
      dump_stmt (di, t);
      dump_child ("body", TREE_OPERAND (t, 0));
      break;

    case USING_STMT:
      dump_stmt (di, t);
      dump_child ("nmsp", USING_STMT_NAMESPACE (t));
      break;

    case CLEANUP_STMT:
      dump_stmt (di, t);
      dump_child ("decl", CLEANUP_DECL (t));
      dump_child ("expr", CLEANUP_EXPR (t));
      dump_child ("body", CLEANUP_BODY (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));
      break;

    case BREAK_STMT:
    case CONTINUE_STMT:
      dump_stmt (di, t);
      break;

    case DO_STMT:
      dump_stmt (di, t);
      dump_child ("body", DO_BODY (t));
      dump_child ("cond", DO_COND (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));
      break;

    case RANGE_FOR_STMT:
      dump_stmt (di, t);
      dump_child ("decl", RANGE_FOR_DECL (t));
      dump_child ("expr", RANGE_FOR_EXPR (t));
      dump_child ("body", RANGE_FOR_BODY (t));
      break;

    case SWITCH_STMT:
      dump_stmt (di, t);
      dump_child ("cond", SWITCH_STMT_COND (t));
      dump_child ("body", SWITCH_STMT_BODY (t));
      break;

    case WHILE_STMT:
      dump_stmt (di, t);
      dump_child ("cond", WHILE_COND (t));
      dump_child ("body", WHILE_BODY (t));
      break;

    case STMT_EXPR:
      dump_child ("stmt", STMT_EXPR_STMT (t));
      break;

    case EXPR_STMT:
      dump_stmt (di, t);
      dump_child ("expr", EXPR_STMT_EXPR (t));
      break;

    default:
      break;
    }

  return c_dump_tree (di, t);
}
Commit	Line	Data
f71f87f9	1	/* Tree-dumping functionality for intermediate representation.
9e1e64ec	2	Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
fbc315db	3	Free Software Foundation, Inc.
f71f87f9 MM	4	Written by Mark Mitchell <mark@codesourcery.com>
f71f87f9 MM	5
f5adbb8d	6	This file is part of GCC.
f71f87f9	7
f5adbb8d	8	GCC is free software; you can redistribute it and/or modify
f71f87f9	9	it under the terms of the GNU General Public License as published by
e77f031d	10	the Free Software Foundation; either version 3, or (at your option)
f71f87f9 MM	11	any later version.
f71f87f9 MM	12
f5adbb8d	13	GCC is distributed in the hope that it will be useful,
f71f87f9 MM	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
e77f031d NC	19	along with GCC; see the file COPYING3. If not see
e77f031d NC	20	<http://www.gnu.org/licenses/>. */
f71f87f9	21
f71f87f9 MM	22	#include "config.h"
f71f87f9 MM	23	#include "system.h"
4977bab6 ZW	24	#include "coretypes.h"
4977bab6 ZW	25	#include "tm.h"
f71f87f9 MM	26	#include "tree.h"
f71f87f9 MM	27	#include "cp-tree.h"
89d684bb	28	#include "tree-dump.h"
f71f87f9	29
ee42dd9d	30	static void dump_access (dump_info_p, tree);
005a5cb0	31
ee42dd9d	32	static void dump_op (dump_info_p, tree);
78a40378	33
005a5cb0 MY	34	/* Dump a representation of the accessibility information associated
	35	with T. */
	36
	37	static void
ee42dd9d	38	dump_access (dump_info_p di, tree t)
005a5cb0 MY	39	{
005a5cb0 MY	40	if (TREE_PROTECTED(t))
1966af04	41	dump_string_field (di, "accs", "prot");
005a5cb0	42	else if (TREE_PRIVATE(t))
1966af04	43	dump_string_field (di, "accs", "priv");
005a5cb0	44	else
1966af04	45	dump_string_field (di, "accs", "pub");
005a5cb0 MY	46	}
005a5cb0 MY	47
78a40378	48	/* Dump a representation of the specific operator for an overloaded
558ee214	49	operator associated with node t. */
78a40378 MM	50
78a40378 MM	51	static void
ee42dd9d	52	dump_op (dump_info_p di, tree t)
78a40378 MM	53	{
	54	switch (DECL_OVERLOADED_OPERATOR_P (t)) {
	55	case NEW_EXPR:
	56	dump_string (di, "new");
	57	break;
	58	case VEC_NEW_EXPR:
	59	dump_string (di, "vecnew");
	60	break;
	61	case DELETE_EXPR:
	62	dump_string (di, "delete");
	63	break;
	64	case VEC_DELETE_EXPR:
	65	dump_string (di, "vecdelete");
	66	break;
392e3d51	67	case UNARY_PLUS_EXPR:
78a40378 MM	68	dump_string (di, "pos");
	69	break;
	70	case NEGATE_EXPR:
	71	dump_string (di, "neg");
	72	break;
	73	case ADDR_EXPR:
	74	dump_string (di, "addr");
	75	break;
	76	case INDIRECT_REF:
	77	dump_string(di, "deref");
	78	break;
	79	case BIT_NOT_EXPR:
	80	dump_string(di, "not");
	81	break;
	82	case TRUTH_NOT_EXPR:
	83	dump_string(di, "lnot");
	84	break;
	85	case PREINCREMENT_EXPR:
	86	dump_string(di, "preinc");
	87	break;
	88	case PREDECREMENT_EXPR:
	89	dump_string(di, "predec");
	90	break;
	91	case PLUS_EXPR:
	92	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	93	dump_string (di, "plusassign");
78a40378	94	else
0cbd7506	95	dump_string(di, "plus");
78a40378 MM	96	break;
	97	case MINUS_EXPR:
	98	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	99	dump_string (di, "minusassign");
78a40378	100	else
0cbd7506	101	dump_string(di, "minus");
78a40378 MM	102	break;
	103	case MULT_EXPR:
	104	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	105	dump_string (di, "multassign");
78a40378	106	else
0cbd7506	107	dump_string (di, "mult");
78a40378 MM	108	break;
	109	case TRUNC_DIV_EXPR:
	110	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	111	dump_string (di, "divassign");
78a40378	112	else
0cbd7506	113	dump_string (di, "div");
78a40378 MM	114	break;
	115	case TRUNC_MOD_EXPR:
	116	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	117	dump_string (di, "modassign");
78a40378	118	else
0cbd7506	119	dump_string (di, "mod");
78a40378 MM	120	break;
	121	case BIT_AND_EXPR:
	122	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	123	dump_string (di, "andassign");
78a40378	124	else
0cbd7506	125	dump_string (di, "and");
78a40378 MM	126	break;
	127	case BIT_IOR_EXPR:
	128	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	129	dump_string (di, "orassign");
78a40378	130	else
0cbd7506	131	dump_string (di, "or");
78a40378 MM	132	break;
	133	case BIT_XOR_EXPR:
	134	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	135	dump_string (di, "xorassign");
78a40378	136	else
0cbd7506	137	dump_string (di, "xor");
78a40378 MM	138	break;
	139	case LSHIFT_EXPR:
	140	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	141	dump_string (di, "lshiftassign");
78a40378	142	else
0cbd7506	143	dump_string (di, "lshift");
78a40378 MM	144	break;
	145	case RSHIFT_EXPR:
	146	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	147	dump_string (di, "rshiftassign");
78a40378	148	else
0cbd7506	149	dump_string (di, "rshift");
78a40378 MM	150	break;
	151	case EQ_EXPR:
	152	dump_string (di, "eq");
	153	break;
	154	case NE_EXPR:
	155	dump_string (di, "ne");
	156	break;
	157	case LT_EXPR:
	158	dump_string (di, "lt");
	159	break;
	160	case GT_EXPR:
	161	dump_string (di, "gt");
	162	break;
	163	case LE_EXPR:
	164	dump_string (di, "le");
	165	break;
	166	case GE_EXPR:
	167	dump_string (di, "ge");
	168	break;
	169	case TRUTH_ANDIF_EXPR:
	170	dump_string (di, "land");
	171	break;
	172	case TRUTH_ORIF_EXPR:
	173	dump_string (di, "lor");
	174	break;
	175	case COMPOUND_EXPR:
	176	dump_string (di, "compound");
	177	break;
	178	case MEMBER_REF:
	179	dump_string (di, "memref");
	180	break;
	181	case COMPONENT_REF:
	182	dump_string (di, "ref");
	183	break;
	184	case ARRAY_REF:
	185	dump_string (di, "subs");
	186	break;
	187	case POSTINCREMENT_EXPR:
c8094d83	188	dump_string (di, "postinc");
78a40378 MM	189	break;
	190	case POSTDECREMENT_EXPR:
	191	dump_string (di, "postdec");
	192	break;
	193	case CALL_EXPR:
	194	dump_string (di, "call");
	195	break;
	196	case NOP_EXPR:
	197	if (DECL_ASSIGNMENT_OPERATOR_P (t))
0cbd7506	198	dump_string (di, "assign");
78a40378 MM	199	break;
	200	default:
	201	break;
	202	}
	203	}
	204
2bd3ecad	205	bool
ee42dd9d	206	cp_dump_tree (void* dump_info, tree t)
f71f87f9	207	{
f71f87f9	208	enum tree_code code;
89d684bb	209	dump_info_p di = (dump_info_p) dump_info;
f71f87f9 MM	210
	211	/* Figure out what kind of node this is. */
	212	code = TREE_CODE (t);
f71f87f9	213
0a7394bc	214	if (DECL_P (t))
f71f87f9	215	{
421844e7	216	if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
1966af04	217	dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
f71f87f9	218	}
f71f87f9	219
f71f87f9 MM	220	switch (code)
f71f87f9 MM	221	{
f71f87f9 MM	222	case IDENTIFIER_NODE:
f71f87f9 MM	223	if (IDENTIFIER_OPNAME_P (t))
0a7394bc	224	{
1966af04	225	dump_string_field (di, "note", "operator");
2bd3ecad	226	return true;
0a7394bc	227	}
f71f87f9	228	else if (IDENTIFIER_TYPENAME_P (t))
f71f87f9	229	{
0a7394bc	230	dump_child ("tynm", TREE_TYPE (t));
2bd3ecad	231	return true;
f71f87f9	232	}
f71f87f9 MM	233	break;
f71f87f9 MM	234
a5ac359a	235	case OFFSET_TYPE:
1966af04	236	dump_string_field (di, "note", "ptrmem");
a5ac359a MM	237	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
	238	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
	239	return true;
f71f87f9 MM	240
f71f87f9 MM	241	case RECORD_TYPE:
f71f87f9 MM	242	if (TYPE_PTRMEMFUNC_P (t))
f71f87f9 MM	243	{
1966af04	244	dump_string_field (di, "note", "ptrmem");
8badec73 MM	245	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
8badec73 MM	246	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
2bd3ecad	247	return true;
f71f87f9	248	}
a5ac359a	249	/* Fall through. */
f71f87f9	250
a5ac359a	251	case UNION_TYPE:
5a5cccaa NS	252	/* Is it a type used as a base? */
	253	if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
	254	&& CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
	255	{
	256	dump_child ("bfld", TYPE_CONTEXT (t));
2bd3ecad	257	return true;
5a5cccaa	258	}
c8094d83	259
9e1e64ec	260	if (! MAYBE_CLASS_TYPE_P (t))
4e8dca1c JM	261	break;
4e8dca1c JM	262
0a7394bc	263	dump_child ("vfld", TYPE_VFIELD (t));
78a40378	264	if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
0cbd7506	265	dump_string(di, "spec");
b7442fb5	266
3758425f	267	if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
b7442fb5 NS	268	{
b7442fb5 NS	269	int i;
fa743e8c NS	270	tree binfo;
fa743e8c NS	271	tree base_binfo;
c8094d83	272
fa743e8c NS	273	for (binfo = TYPE_BINFO (t), i = 0;
fa743e8c NS	274	BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
b7442fb5	275	{
b7442fb5	276	dump_child ("base", BINFO_TYPE (base_binfo));
c8094d83	277	if (BINFO_VIRTUAL_P (base_binfo))
1966af04	278	dump_string_field (di, "spec", "virt");
b7442fb5 NS	279	dump_access (di, base_binfo);
	280	}
	281	}
005a5cb0 MY	282	break;
	283
	284	case FIELD_DECL:
	285	dump_access (di, t);
78a40378	286	if (DECL_MUTABLE_P (t))
1966af04	287	dump_string_field (di, "spec", "mutable");
f71f87f9 MM	288	break;
f71f87f9 MM	289
78a40378 MM	290	case VAR_DECL:
78a40378 MM	291	if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
0cbd7506	292	dump_access (di, t);
78a40378	293	if (TREE_STATIC (t) && !TREE_PUBLIC (t))
1966af04	294	dump_string_field (di, "link", "static");
c8094d83	295	break;
78a40378	296
f71f87f9	297	case FUNCTION_DECL:
31f8e4f3	298	if (!DECL_THUNK_P (t))
e9e7f181	299	{
0cbd7506	300	if (DECL_OVERLOADED_OPERATOR_P (t)) {
1966af04	301	dump_string_field (di, "note", "operator");
0cbd7506 MS	302	dump_op (di, t);
0cbd7506 MS	303	}
c8094d83	304	if (DECL_FUNCTION_MEMBER_P (t))
005a5cb0	305	{
1966af04	306	dump_string_field (di, "note", "member");
005a5cb0 MY	307	dump_access (di, t);
005a5cb0 MY	308	}
0cbd7506	309	if (DECL_PURE_VIRTUAL_P (t))
1966af04	310	dump_string_field (di, "spec", "pure");
0cbd7506	311	if (DECL_VIRTUAL_P (t))
1966af04	312	dump_string_field (di, "spec", "virt");
e9e7f181	313	if (DECL_CONSTRUCTOR_P (t))
1966af04	314	dump_string_field (di, "note", "constructor");
e9e7f181	315	if (DECL_DESTRUCTOR_P (t))
1966af04	316	dump_string_field (di, "note", "destructor");
e9e7f181	317	if (DECL_CONV_FN_P (t))
1966af04	318	dump_string_field (di, "note", "conversion");
4977bab6	319	if (DECL_GLOBAL_CTOR_P (t))
1966af04	320	dump_string_field (di, "note", "global init");
4977bab6	321	if (DECL_GLOBAL_DTOR_P (t))
1966af04	322	dump_string_field (di, "note", "global fini");
1c227897	323	if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
1966af04	324	dump_string_field (di, "note", "pseudo tmpl");
e9e7f181 MM	325	}
	326	else
	327	{
07fa4878	328	tree virt = THUNK_VIRTUAL_OFFSET (t);
c8094d83	329
1966af04	330	dump_string_field (di, "note", "thunk");
4977bab6	331	if (DECL_THIS_THUNK_P (t))
1966af04	332	dump_string_field (di, "note", "this adjusting");
4977bab6	333	else
07fa4878	334	{
1966af04	335	dump_string_field (di, "note", "result adjusting");
07fa4878 NS	336	if (virt)
	337	virt = BINFO_VPTR_FIELD (virt);
	338	}
4977bab6	339	dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
07fa4878 NS	340	if (virt)
07fa4878 NS	341	dump_int (di, "virt", tree_low_cst (virt, 0));
31f8e4f3	342	dump_child ("fn", DECL_INITIAL (t));
e9e7f181	343	}
f71f87f9 MM	344	break;
	345
	346	case NAMESPACE_DECL:
89c6e7ac MM	347	if (DECL_NAMESPACE_ALIAS (t))
89c6e7ac MM	348	dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
b7442fb5	349	else if (!dump_flag (di, TDF_SLIM, t))
89c6e7ac	350	dump_child ("dcls", cp_namespace_decls (t));
f71f87f9 MM	351	break;
f71f87f9 MM	352
cfe507be	353	case TEMPLATE_DECL:
da8a7456	354	dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
2269eec3	355	dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
3454335f	356	dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
005a5cb0	357	dump_child ("prms", DECL_TEMPLATE_PARMS (t));
cfe507be MM	358	break;
cfe507be MM	359
f71f87f9	360	case OVERLOAD:
3454335f MM	361	dump_child ("crnt", OVL_CURRENT (t));
3454335f MM	362	dump_child ("chan", OVL_CHAIN (t));
f71f87f9 MM	363	break;
f71f87f9 MM	364
0a7394bc	365	case TRY_BLOCK:
f71f87f9	366	dump_stmt (di, t);
0a7394bc	367	if (CLEANUP_P (t))
1966af04	368	dump_string_field (di, "note", "cleanup");
0a7394bc MM	369	dump_child ("body", TRY_STMTS (t));
0a7394bc MM	370	dump_child ("hdlr", TRY_HANDLERS (t));
f71f87f9 MM	371	break;
f71f87f9 MM	372
52a11cbf RH	373	case EH_SPEC_BLOCK:
	374	dump_stmt (di, t);
	375	dump_child ("body", EH_SPEC_STMTS (t));
	376	dump_child ("raises", EH_SPEC_RAISES (t));
52a11cbf RH	377	break;
52a11cbf RH	378
0a7394bc MM	379	case PTRMEM_CST:
	380	dump_child ("clas", PTRMEM_CST_CLASS (t));
	381	dump_child ("mbr", PTRMEM_CST_MEMBER (t));
f71f87f9 MM	382	break;
f71f87f9 MM	383
0a7394bc MM	384	case THROW_EXPR:
	385	/* These nodes are unary, but do not have code class `1'. */
	386	dump_child ("op 0", TREE_OPERAND (t, 0));
f71f87f9 MM	387	break;
f71f87f9 MM	388
0a7394bc	389	case AGGR_INIT_EXPR:
5039610b SL	390	{
	391	int i = 0;
	392	tree arg;
	393	aggr_init_expr_arg_iterator iter;
	394	dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
	395	dump_child ("fn", AGGR_INIT_EXPR_FN (t));
	396	FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
	397	{
	398	char buffer[32];
	399	sprintf (buffer, "%u", i);
	400	dump_child (buffer, arg);
	401	i++;
	402	}
	403	dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
	404	}
0a7394bc	405	break;
c8094d83	406
a2edce31 MM	407	case HANDLER:
a2edce31 MM	408	dump_stmt (di, t);
1a6025b4	409	dump_child ("parm", HANDLER_PARMS (t));
a2edce31	410	dump_child ("body", HANDLER_BODY (t));
a2edce31 MM	411	break;
a2edce31 MM	412
52a11cbf RH	413	case MUST_NOT_THROW_EXPR:
	414	dump_stmt (di, t);
	415	dump_child ("body", TREE_OPERAND (t, 0));
52a11cbf RH	416	break;
52a11cbf RH	417
5158d7ee NS	418	case USING_STMT:
	419	dump_stmt (di, t);
	420	dump_child ("nmsp", USING_STMT_NAMESPACE (t));
5158d7ee	421	break;
5a508662 RH	422
	423	case CLEANUP_STMT:
	424	dump_stmt (di, t);
	425	dump_child ("decl", CLEANUP_DECL (t));
	426	dump_child ("expr", CLEANUP_EXPR (t));
	427	dump_child ("body", CLEANUP_BODY (t));
5a508662 RH	428	break;
	429
	430	case IF_STMT:
	431	dump_stmt (di, t);
	432	dump_child ("cond", IF_COND (t));
	433	dump_child ("then", THEN_CLAUSE (t));
	434	dump_child ("else", ELSE_CLAUSE (t));
5a508662 RH	435	break;
5a508662 RH	436
fbc315db ILT	437	case BREAK_STMT:
	438	case CONTINUE_STMT:
	439	dump_stmt (di, t);
	440	break;
	441
	442	case DO_STMT:
	443	dump_stmt (di, t);
	444	dump_child ("body", DO_BODY (t));
	445	dump_child ("cond", DO_COND (t));
	446	break;
	447
	448	case FOR_STMT:
	449	dump_stmt (di, t);
	450	dump_child ("init", FOR_INIT_STMT (t));
	451	dump_child ("cond", FOR_COND (t));
	452	dump_child ("expr", FOR_EXPR (t));
	453	dump_child ("body", FOR_BODY (t));
	454	break;
	455
f9132eb7 RRC	456	case RANGE_FOR_STMT:
	457	dump_stmt (di, t);
	458	dump_child ("decl", RANGE_FOR_DECL (t));
	459	dump_child ("expr", RANGE_FOR_EXPR (t));
	460	dump_child ("body", RANGE_FOR_BODY (t));
	461	break;
	462
fbc315db ILT	463	case SWITCH_STMT:
	464	dump_stmt (di, t);
	465	dump_child ("cond", SWITCH_STMT_COND (t));
	466	dump_child ("body", SWITCH_STMT_BODY (t));
	467	break;
	468
	469	case WHILE_STMT:
	470	dump_stmt (di, t);
	471	dump_child ("cond", WHILE_COND (t));
	472	dump_child ("body", WHILE_BODY (t));
	473	break;
	474
c3e5898b ILT	475	case STMT_EXPR:
	476	dump_child ("stmt", STMT_EXPR_STMT (t));
	477	break;
	478
934790cc ILT	479	case EXPR_STMT:
	480	dump_stmt (di, t);
	481	dump_child ("expr", EXPR_STMT_EXPR (t));
	482	break;
	483
f71f87f9	484	default:
f71f87f9 MM	485	break;
	486	}
	487
558ee214	488	return c_dump_tree (di, t);
f71f87f9	489	}