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

/* Tree-dumping functionality for intermediate representation.
   Copyright (C) 1999-2015 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 "alias.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;
  }
}

/* Dump information common to statements from STMT.  */

static void
dump_stmt (dump_info_p di, const_tree t)
{
  if (EXPR_HAS_LOCATION (t))
    dump_int (di, "line", EXPR_LINENO (t));
}

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_to_shwi (virt));
	  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));
      dump_child ("cond", MUST_NOT_THROW_COND (t));
      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
ddea175e	1	/* Tree-dumping functionality for intermediate representation.
d353bf18	2	Copyright (C) 1999-2015 Free Software Foundation, Inc.
ddea175e	3	Written by Mark Mitchell <mark@codesourcery.com>
ddea175e	4
6f0d25a6	5	This file is part of GCC.
ddea175e	6
6f0d25a6	7	GCC is free software; you can redistribute it and/or modify
ddea175e	8	it under the terms of the GNU General Public License as published by
aa139c3f	9	the Free Software Foundation; either version 3, or (at your option)
ddea175e	10	any later version.
ddea175e	11
6f0d25a6	12	GCC is distributed in the hope that it will be useful,
ddea175e	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
aa139c3f	18	along with GCC; see the file COPYING3. If not see
aa139c3f	19	<http://www.gnu.org/licenses/>. */
ddea175e	20
ddea175e	21	#include "config.h"
ddea175e	22	#include "system.h"
805e22b2	23	#include "coretypes.h"
805e22b2	24	#include "tm.h"
b20a8bb4	25	#include "alias.h"
ddea175e	26	#include "tree.h"
ddea175e	27	#include "cp-tree.h"
3119c950	28	#include "tree-dump.h"
ddea175e	29
5fc6d49c	30	static void dump_access (dump_info_p, tree);
fa1e684b	31
5fc6d49c	32	static void dump_op (dump_info_p, tree);
c2465d5d	33
fa1e684b	34	/* Dump a representation of the accessibility information associated
	35	with T. */
	36
	37	static void
5fc6d49c	38	dump_access (dump_info_p di, tree t)
fa1e684b	39	{
fa1e684b	40	if (TREE_PROTECTED(t))
5a471c32	41	dump_string_field (di, "accs", "prot");
fa1e684b	42	else if (TREE_PRIVATE(t))
5a471c32	43	dump_string_field (di, "accs", "priv");
fa1e684b	44	else
5a471c32	45	dump_string_field (di, "accs", "pub");
fa1e684b	46	}
fa1e684b	47
c2465d5d	48	/* Dump a representation of the specific operator for an overloaded
d571f56f	49	operator associated with node t. */
c2465d5d	50
c2465d5d	51	static void
5fc6d49c	52	dump_op (dump_info_p di, tree t)
c2465d5d	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;
97d541d5	67	case UNARY_PLUS_EXPR:
c2465d5d	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))
653e5405	93	dump_string (di, "plusassign");
c2465d5d	94	else
653e5405	95	dump_string(di, "plus");
c2465d5d	96	break;
	97	case MINUS_EXPR:
	98	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	99	dump_string (di, "minusassign");
c2465d5d	100	else
653e5405	101	dump_string(di, "minus");
c2465d5d	102	break;
	103	case MULT_EXPR:
	104	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	105	dump_string (di, "multassign");
c2465d5d	106	else
653e5405	107	dump_string (di, "mult");
c2465d5d	108	break;
	109	case TRUNC_DIV_EXPR:
	110	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	111	dump_string (di, "divassign");
c2465d5d	112	else
653e5405	113	dump_string (di, "div");
c2465d5d	114	break;
	115	case TRUNC_MOD_EXPR:
	116	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	117	dump_string (di, "modassign");
c2465d5d	118	else
653e5405	119	dump_string (di, "mod");
c2465d5d	120	break;
	121	case BIT_AND_EXPR:
	122	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	123	dump_string (di, "andassign");
c2465d5d	124	else
653e5405	125	dump_string (di, "and");
c2465d5d	126	break;
	127	case BIT_IOR_EXPR:
	128	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	129	dump_string (di, "orassign");
c2465d5d	130	else
653e5405	131	dump_string (di, "or");
c2465d5d	132	break;
	133	case BIT_XOR_EXPR:
	134	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	135	dump_string (di, "xorassign");
c2465d5d	136	else
653e5405	137	dump_string (di, "xor");
c2465d5d	138	break;
	139	case LSHIFT_EXPR:
	140	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	141	dump_string (di, "lshiftassign");
c2465d5d	142	else
653e5405	143	dump_string (di, "lshift");
c2465d5d	144	break;
	145	case RSHIFT_EXPR:
	146	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	147	dump_string (di, "rshiftassign");
c2465d5d	148	else
653e5405	149	dump_string (di, "rshift");
c2465d5d	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:
9031d10b	188	dump_string (di, "postinc");
c2465d5d	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))
653e5405	198	dump_string (di, "assign");
c2465d5d	199	break;
	200	default:
	201	break;
	202	}
	203	}
	204
b9ed1410	205	/* Dump information common to statements from STMT. */
	206
	207	static void
	208	dump_stmt (dump_info_p di, const_tree t)
	209	{
	210	if (EXPR_HAS_LOCATION (t))
	211	dump_int (di, "line", EXPR_LINENO (t));
	212	}
	213
fb84380a	214	bool
5fc6d49c	215	cp_dump_tree (void* dump_info, tree t)
ddea175e	216	{
ddea175e	217	enum tree_code code;
3119c950	218	dump_info_p di = (dump_info_p) dump_info;
ddea175e	219
	220	/* Figure out what kind of node this is. */
	221	code = TREE_CODE (t);
ddea175e	222
c25509f2	223	if (DECL_P (t))
ddea175e	224	{
f0edcca6	225	if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
5a471c32	226	dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
ddea175e	227	}
ddea175e	228
ddea175e	229	switch (code)
ddea175e	230	{
ddea175e	231	case IDENTIFIER_NODE:
ddea175e	232	if (IDENTIFIER_OPNAME_P (t))
c25509f2	233	{
5a471c32	234	dump_string_field (di, "note", "operator");
fb84380a	235	return true;
c25509f2	236	}
ddea175e	237	else if (IDENTIFIER_TYPENAME_P (t))
ddea175e	238	{
c25509f2	239	dump_child ("tynm", TREE_TYPE (t));
fb84380a	240	return true;
ddea175e	241	}
ddea175e	242	break;
ddea175e	243
1bc16cab	244	case OFFSET_TYPE:
5a471c32	245	dump_string_field (di, "note", "ptrmem");
1bc16cab	246	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
	247	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
	248	return true;
ddea175e	249
ddea175e	250	case RECORD_TYPE:
ddea175e	251	if (TYPE_PTRMEMFUNC_P (t))
ddea175e	252	{
5a471c32	253	dump_string_field (di, "note", "ptrmem");
704f03c4	254	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
704f03c4	255	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
fb84380a	256	return true;
ddea175e	257	}
1bc16cab	258	/* Fall through. */
ddea175e	259
1bc16cab	260	case UNION_TYPE:
4b09de30	261	/* Is it a type used as a base? */
	262	if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
	263	&& CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
	264	{
	265	dump_child ("bfld", TYPE_CONTEXT (t));
fb84380a	266	return true;
4b09de30	267	}
9031d10b	268
95397ff9	269	if (! MAYBE_CLASS_TYPE_P (t))
bdb2219e	270	break;
bdb2219e	271
c25509f2	272	dump_child ("vfld", TYPE_VFIELD (t));
c2465d5d	273	if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
653e5405	274	dump_string(di, "spec");
364c0b82	275
8a176c0b	276	if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
364c0b82	277	{
364c0b82	278	int i;
f6cc6a08	279	tree binfo;
f6cc6a08	280	tree base_binfo;
9031d10b	281
f6cc6a08	282	for (binfo = TYPE_BINFO (t), i = 0;
f6cc6a08	283	BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
364c0b82	284	{
364c0b82	285	dump_child ("base", BINFO_TYPE (base_binfo));
9031d10b	286	if (BINFO_VIRTUAL_P (base_binfo))
5a471c32	287	dump_string_field (di, "spec", "virt");
364c0b82	288	dump_access (di, base_binfo);
	289	}
	290	}
fa1e684b	291	break;
	292
	293	case FIELD_DECL:
	294	dump_access (di, t);
c2465d5d	295	if (DECL_MUTABLE_P (t))
5a471c32	296	dump_string_field (di, "spec", "mutable");
ddea175e	297	break;
ddea175e	298
c2465d5d	299	case VAR_DECL:
c2465d5d	300	if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
653e5405	301	dump_access (di, t);
c2465d5d	302	if (TREE_STATIC (t) && !TREE_PUBLIC (t))
5a471c32	303	dump_string_field (di, "link", "static");
9031d10b	304	break;
c2465d5d	305
ddea175e	306	case FUNCTION_DECL:
2b82dde2	307	if (!DECL_THUNK_P (t))
74e1778a	308	{
653e5405	309	if (DECL_OVERLOADED_OPERATOR_P (t)) {
5a471c32	310	dump_string_field (di, "note", "operator");
653e5405	311	dump_op (di, t);
653e5405	312	}
9031d10b	313	if (DECL_FUNCTION_MEMBER_P (t))
fa1e684b	314	{
5a471c32	315	dump_string_field (di, "note", "member");
fa1e684b	316	dump_access (di, t);
fa1e684b	317	}
653e5405	318	if (DECL_PURE_VIRTUAL_P (t))
5a471c32	319	dump_string_field (di, "spec", "pure");
653e5405	320	if (DECL_VIRTUAL_P (t))
5a471c32	321	dump_string_field (di, "spec", "virt");
74e1778a	322	if (DECL_CONSTRUCTOR_P (t))
5a471c32	323	dump_string_field (di, "note", "constructor");
74e1778a	324	if (DECL_DESTRUCTOR_P (t))
5a471c32	325	dump_string_field (di, "note", "destructor");
74e1778a	326	if (DECL_CONV_FN_P (t))
5a471c32	327	dump_string_field (di, "note", "conversion");
805e22b2	328	if (DECL_GLOBAL_CTOR_P (t))
5a471c32	329	dump_string_field (di, "note", "global init");
805e22b2	330	if (DECL_GLOBAL_DTOR_P (t))
5a471c32	331	dump_string_field (di, "note", "global fini");
671116bf	332	if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
5a471c32	333	dump_string_field (di, "note", "pseudo tmpl");
74e1778a	334	}
	335	else
	336	{
71b1859a	337	tree virt = THUNK_VIRTUAL_OFFSET (t);
9031d10b	338
5a471c32	339	dump_string_field (di, "note", "thunk");
805e22b2	340	if (DECL_THIS_THUNK_P (t))
5a471c32	341	dump_string_field (di, "note", "this adjusting");
805e22b2	342	else
71b1859a	343	{
5a471c32	344	dump_string_field (di, "note", "result adjusting");
71b1859a	345	if (virt)
	346	virt = BINFO_VPTR_FIELD (virt);
	347	}
805e22b2	348	dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
71b1859a	349	if (virt)
fcb97e84	350	dump_int (di, "virt", tree_to_shwi (virt));
2b82dde2	351	dump_child ("fn", DECL_INITIAL (t));
74e1778a	352	}
ddea175e	353	break;
	354
	355	case NAMESPACE_DECL:
968eccb1	356	if (DECL_NAMESPACE_ALIAS (t))
968eccb1	357	dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
364c0b82	358	else if (!dump_flag (di, TDF_SLIM, t))
968eccb1	359	dump_child ("dcls", cp_namespace_decls (t));
ddea175e	360	break;
ddea175e	361
900f01f2	362	case TEMPLATE_DECL:
52d6ab53	363	dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
9b814097	364	dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
7806a559	365	dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
fa1e684b	366	dump_child ("prms", DECL_TEMPLATE_PARMS (t));
900f01f2	367	break;
900f01f2	368
ddea175e	369	case OVERLOAD:
7806a559	370	dump_child ("crnt", OVL_CURRENT (t));
7806a559	371	dump_child ("chan", OVL_CHAIN (t));
ddea175e	372	break;
ddea175e	373
c25509f2	374	case TRY_BLOCK:
ddea175e	375	dump_stmt (di, t);
c25509f2	376	if (CLEANUP_P (t))
5a471c32	377	dump_string_field (di, "note", "cleanup");
c25509f2	378	dump_child ("body", TRY_STMTS (t));
c25509f2	379	dump_child ("hdlr", TRY_HANDLERS (t));
ddea175e	380	break;
ddea175e	381
df4b504c	382	case EH_SPEC_BLOCK:
	383	dump_stmt (di, t);
	384	dump_child ("body", EH_SPEC_STMTS (t));
	385	dump_child ("raises", EH_SPEC_RAISES (t));
df4b504c	386	break;
df4b504c	387
c25509f2	388	case PTRMEM_CST:
	389	dump_child ("clas", PTRMEM_CST_CLASS (t));
	390	dump_child ("mbr", PTRMEM_CST_MEMBER (t));
ddea175e	391	break;
ddea175e	392
c25509f2	393	case THROW_EXPR:
	394	/* These nodes are unary, but do not have code class `1'. */
	395	dump_child ("op 0", TREE_OPERAND (t, 0));
ddea175e	396	break;
ddea175e	397
c25509f2	398	case AGGR_INIT_EXPR:
c2f47e15	399	{
	400	int i = 0;
	401	tree arg;
	402	aggr_init_expr_arg_iterator iter;
	403	dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
	404	dump_child ("fn", AGGR_INIT_EXPR_FN (t));
	405	FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
	406	{
	407	char buffer[32];
	408	sprintf (buffer, "%u", i);
	409	dump_child (buffer, arg);
	410	i++;
	411	}
	412	dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
	413	}
c25509f2	414	break;
9031d10b	415
e75beec7	416	case HANDLER:
e75beec7	417	dump_stmt (di, t);
6993fb0a	418	dump_child ("parm", HANDLER_PARMS (t));
e75beec7	419	dump_child ("body", HANDLER_BODY (t));
e75beec7	420	break;
e75beec7	421
df4b504c	422	case MUST_NOT_THROW_EXPR:
	423	dump_stmt (di, t);
	424	dump_child ("body", TREE_OPERAND (t, 0));
f9069149	425	dump_child ("cond", MUST_NOT_THROW_COND (t));
df4b504c	426	break;
df4b504c	427
85a363ce	428	case USING_STMT:
	429	dump_stmt (di, t);
	430	dump_child ("nmsp", USING_STMT_NAMESPACE (t));
85a363ce	431	break;
dddab69e	432
	433	case CLEANUP_STMT:
	434	dump_stmt (di, t);
	435	dump_child ("decl", CLEANUP_DECL (t));
	436	dump_child ("expr", CLEANUP_EXPR (t));
	437	dump_child ("body", CLEANUP_BODY (t));
dddab69e	438	break;
	439
	440	case IF_STMT:
	441	dump_stmt (di, t);
	442	dump_child ("cond", IF_COND (t));
	443	dump_child ("then", THEN_CLAUSE (t));
	444	dump_child ("else", ELSE_CLAUSE (t));
dddab69e	445	break;
dddab69e	446
e7911019	447	case BREAK_STMT:
	448	case CONTINUE_STMT:
	449	dump_stmt (di, t);
	450	break;
	451
	452	case DO_STMT:
	453	dump_stmt (di, t);
	454	dump_child ("body", DO_BODY (t));
	455	dump_child ("cond", DO_COND (t));
	456	break;
	457
	458	case FOR_STMT:
	459	dump_stmt (di, t);
	460	dump_child ("init", FOR_INIT_STMT (t));
	461	dump_child ("cond", FOR_COND (t));
	462	dump_child ("expr", FOR_EXPR (t));
	463	dump_child ("body", FOR_BODY (t));
	464	break;
	465
9dd72ec4	466	case RANGE_FOR_STMT:
	467	dump_stmt (di, t);
	468	dump_child ("decl", RANGE_FOR_DECL (t));
	469	dump_child ("expr", RANGE_FOR_EXPR (t));
	470	dump_child ("body", RANGE_FOR_BODY (t));
	471	break;
	472
e7911019	473	case SWITCH_STMT:
	474	dump_stmt (di, t);
	475	dump_child ("cond", SWITCH_STMT_COND (t));
	476	dump_child ("body", SWITCH_STMT_BODY (t));
	477	break;
	478
	479	case WHILE_STMT:
	480	dump_stmt (di, t);
	481	dump_child ("cond", WHILE_COND (t));
	482	dump_child ("body", WHILE_BODY (t));
	483	break;
	484
57f08f11	485	case STMT_EXPR:
	486	dump_child ("stmt", STMT_EXPR_STMT (t));
	487	break;
	488
7219fab5	489	case EXPR_STMT:
	490	dump_stmt (di, t);
	491	dump_child ("expr", EXPR_STMT_EXPR (t));
	492	break;
	493
ddea175e	494	default:
ddea175e	495	break;
	496	}
	497
d571f56f	498	return c_dump_tree (di, t);
ddea175e	499	}