[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 "symtab.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"
b20a8bb4	26	#include "symtab.h"
ddea175e	27	#include "tree.h"
ddea175e	28	#include "cp-tree.h"
3119c950	29	#include "tree-dump.h"
ddea175e	30
5fc6d49c	31	static void dump_access (dump_info_p, tree);
fa1e684b	32
5fc6d49c	33	static void dump_op (dump_info_p, tree);
c2465d5d	34
fa1e684b	35	/* Dump a representation of the accessibility information associated
	36	with T. */
	37
	38	static void
5fc6d49c	39	dump_access (dump_info_p di, tree t)
fa1e684b	40	{
fa1e684b	41	if (TREE_PROTECTED(t))
5a471c32	42	dump_string_field (di, "accs", "prot");
fa1e684b	43	else if (TREE_PRIVATE(t))
5a471c32	44	dump_string_field (di, "accs", "priv");
fa1e684b	45	else
5a471c32	46	dump_string_field (di, "accs", "pub");
fa1e684b	47	}
fa1e684b	48
c2465d5d	49	/* Dump a representation of the specific operator for an overloaded
d571f56f	50	operator associated with node t. */
c2465d5d	51
c2465d5d	52	static void
5fc6d49c	53	dump_op (dump_info_p di, tree t)
c2465d5d	54	{
	55	switch (DECL_OVERLOADED_OPERATOR_P (t)) {
	56	case NEW_EXPR:
	57	dump_string (di, "new");
	58	break;
	59	case VEC_NEW_EXPR:
	60	dump_string (di, "vecnew");
	61	break;
	62	case DELETE_EXPR:
	63	dump_string (di, "delete");
	64	break;
	65	case VEC_DELETE_EXPR:
	66	dump_string (di, "vecdelete");
	67	break;
97d541d5	68	case UNARY_PLUS_EXPR:
c2465d5d	69	dump_string (di, "pos");
	70	break;
	71	case NEGATE_EXPR:
	72	dump_string (di, "neg");
	73	break;
	74	case ADDR_EXPR:
	75	dump_string (di, "addr");
	76	break;
	77	case INDIRECT_REF:
	78	dump_string(di, "deref");
	79	break;
	80	case BIT_NOT_EXPR:
	81	dump_string(di, "not");
	82	break;
	83	case TRUTH_NOT_EXPR:
	84	dump_string(di, "lnot");
	85	break;
	86	case PREINCREMENT_EXPR:
	87	dump_string(di, "preinc");
	88	break;
	89	case PREDECREMENT_EXPR:
	90	dump_string(di, "predec");
	91	break;
	92	case PLUS_EXPR:
	93	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	94	dump_string (di, "plusassign");
c2465d5d	95	else
653e5405	96	dump_string(di, "plus");
c2465d5d	97	break;
	98	case MINUS_EXPR:
	99	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	100	dump_string (di, "minusassign");
c2465d5d	101	else
653e5405	102	dump_string(di, "minus");
c2465d5d	103	break;
	104	case MULT_EXPR:
	105	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	106	dump_string (di, "multassign");
c2465d5d	107	else
653e5405	108	dump_string (di, "mult");
c2465d5d	109	break;
	110	case TRUNC_DIV_EXPR:
	111	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	112	dump_string (di, "divassign");
c2465d5d	113	else
653e5405	114	dump_string (di, "div");
c2465d5d	115	break;
	116	case TRUNC_MOD_EXPR:
	117	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	118	dump_string (di, "modassign");
c2465d5d	119	else
653e5405	120	dump_string (di, "mod");
c2465d5d	121	break;
	122	case BIT_AND_EXPR:
	123	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	124	dump_string (di, "andassign");
c2465d5d	125	else
653e5405	126	dump_string (di, "and");
c2465d5d	127	break;
	128	case BIT_IOR_EXPR:
	129	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	130	dump_string (di, "orassign");
c2465d5d	131	else
653e5405	132	dump_string (di, "or");
c2465d5d	133	break;
	134	case BIT_XOR_EXPR:
	135	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	136	dump_string (di, "xorassign");
c2465d5d	137	else
653e5405	138	dump_string (di, "xor");
c2465d5d	139	break;
	140	case LSHIFT_EXPR:
	141	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	142	dump_string (di, "lshiftassign");
c2465d5d	143	else
653e5405	144	dump_string (di, "lshift");
c2465d5d	145	break;
	146	case RSHIFT_EXPR:
	147	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	148	dump_string (di, "rshiftassign");
c2465d5d	149	else
653e5405	150	dump_string (di, "rshift");
c2465d5d	151	break;
	152	case EQ_EXPR:
	153	dump_string (di, "eq");
	154	break;
	155	case NE_EXPR:
	156	dump_string (di, "ne");
	157	break;
	158	case LT_EXPR:
	159	dump_string (di, "lt");
	160	break;
	161	case GT_EXPR:
	162	dump_string (di, "gt");
	163	break;
	164	case LE_EXPR:
	165	dump_string (di, "le");
	166	break;
	167	case GE_EXPR:
	168	dump_string (di, "ge");
	169	break;
	170	case TRUTH_ANDIF_EXPR:
	171	dump_string (di, "land");
	172	break;
	173	case TRUTH_ORIF_EXPR:
	174	dump_string (di, "lor");
	175	break;
	176	case COMPOUND_EXPR:
	177	dump_string (di, "compound");
	178	break;
	179	case MEMBER_REF:
	180	dump_string (di, "memref");
	181	break;
	182	case COMPONENT_REF:
	183	dump_string (di, "ref");
	184	break;
	185	case ARRAY_REF:
	186	dump_string (di, "subs");
	187	break;
	188	case POSTINCREMENT_EXPR:
9031d10b	189	dump_string (di, "postinc");
c2465d5d	190	break;
	191	case POSTDECREMENT_EXPR:
	192	dump_string (di, "postdec");
	193	break;
	194	case CALL_EXPR:
	195	dump_string (di, "call");
	196	break;
	197	case NOP_EXPR:
	198	if (DECL_ASSIGNMENT_OPERATOR_P (t))
653e5405	199	dump_string (di, "assign");
c2465d5d	200	break;
	201	default:
	202	break;
	203	}
	204	}
	205
b9ed1410	206	/* Dump information common to statements from STMT. */
	207
	208	static void
	209	dump_stmt (dump_info_p di, const_tree t)
	210	{
	211	if (EXPR_HAS_LOCATION (t))
	212	dump_int (di, "line", EXPR_LINENO (t));
	213	}
	214
fb84380a	215	bool
5fc6d49c	216	cp_dump_tree (void* dump_info, tree t)
ddea175e	217	{
ddea175e	218	enum tree_code code;
3119c950	219	dump_info_p di = (dump_info_p) dump_info;
ddea175e	220
	221	/* Figure out what kind of node this is. */
	222	code = TREE_CODE (t);
ddea175e	223
c25509f2	224	if (DECL_P (t))
ddea175e	225	{
f0edcca6	226	if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
5a471c32	227	dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
ddea175e	228	}
ddea175e	229
ddea175e	230	switch (code)
ddea175e	231	{
ddea175e	232	case IDENTIFIER_NODE:
ddea175e	233	if (IDENTIFIER_OPNAME_P (t))
c25509f2	234	{
5a471c32	235	dump_string_field (di, "note", "operator");
fb84380a	236	return true;
c25509f2	237	}
ddea175e	238	else if (IDENTIFIER_TYPENAME_P (t))
ddea175e	239	{
c25509f2	240	dump_child ("tynm", TREE_TYPE (t));
fb84380a	241	return true;
ddea175e	242	}
ddea175e	243	break;
ddea175e	244
1bc16cab	245	case OFFSET_TYPE:
5a471c32	246	dump_string_field (di, "note", "ptrmem");
1bc16cab	247	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
	248	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
	249	return true;
ddea175e	250
ddea175e	251	case RECORD_TYPE:
ddea175e	252	if (TYPE_PTRMEMFUNC_P (t))
ddea175e	253	{
5a471c32	254	dump_string_field (di, "note", "ptrmem");
704f03c4	255	dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
704f03c4	256	dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
fb84380a	257	return true;
ddea175e	258	}
1bc16cab	259	/* Fall through. */
ddea175e	260
1bc16cab	261	case UNION_TYPE:
4b09de30	262	/* Is it a type used as a base? */
	263	if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
	264	&& CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
	265	{
	266	dump_child ("bfld", TYPE_CONTEXT (t));
fb84380a	267	return true;
4b09de30	268	}
9031d10b	269
95397ff9	270	if (! MAYBE_CLASS_TYPE_P (t))
bdb2219e	271	break;
bdb2219e	272
c25509f2	273	dump_child ("vfld", TYPE_VFIELD (t));
c2465d5d	274	if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
653e5405	275	dump_string(di, "spec");
364c0b82	276
8a176c0b	277	if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
364c0b82	278	{
364c0b82	279	int i;
f6cc6a08	280	tree binfo;
f6cc6a08	281	tree base_binfo;
9031d10b	282
f6cc6a08	283	for (binfo = TYPE_BINFO (t), i = 0;
f6cc6a08	284	BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
364c0b82	285	{
364c0b82	286	dump_child ("base", BINFO_TYPE (base_binfo));
9031d10b	287	if (BINFO_VIRTUAL_P (base_binfo))
5a471c32	288	dump_string_field (di, "spec", "virt");
364c0b82	289	dump_access (di, base_binfo);
	290	}
	291	}
fa1e684b	292	break;
	293
	294	case FIELD_DECL:
	295	dump_access (di, t);
c2465d5d	296	if (DECL_MUTABLE_P (t))
5a471c32	297	dump_string_field (di, "spec", "mutable");
ddea175e	298	break;
ddea175e	299
c2465d5d	300	case VAR_DECL:
c2465d5d	301	if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
653e5405	302	dump_access (di, t);
c2465d5d	303	if (TREE_STATIC (t) && !TREE_PUBLIC (t))
5a471c32	304	dump_string_field (di, "link", "static");
9031d10b	305	break;
c2465d5d	306
ddea175e	307	case FUNCTION_DECL:
2b82dde2	308	if (!DECL_THUNK_P (t))
74e1778a	309	{
653e5405	310	if (DECL_OVERLOADED_OPERATOR_P (t)) {
5a471c32	311	dump_string_field (di, "note", "operator");
653e5405	312	dump_op (di, t);
653e5405	313	}
9031d10b	314	if (DECL_FUNCTION_MEMBER_P (t))
fa1e684b	315	{
5a471c32	316	dump_string_field (di, "note", "member");
fa1e684b	317	dump_access (di, t);
fa1e684b	318	}
653e5405	319	if (DECL_PURE_VIRTUAL_P (t))
5a471c32	320	dump_string_field (di, "spec", "pure");
653e5405	321	if (DECL_VIRTUAL_P (t))
5a471c32	322	dump_string_field (di, "spec", "virt");
74e1778a	323	if (DECL_CONSTRUCTOR_P (t))
5a471c32	324	dump_string_field (di, "note", "constructor");
74e1778a	325	if (DECL_DESTRUCTOR_P (t))
5a471c32	326	dump_string_field (di, "note", "destructor");
74e1778a	327	if (DECL_CONV_FN_P (t))
5a471c32	328	dump_string_field (di, "note", "conversion");
805e22b2	329	if (DECL_GLOBAL_CTOR_P (t))
5a471c32	330	dump_string_field (di, "note", "global init");
805e22b2	331	if (DECL_GLOBAL_DTOR_P (t))
5a471c32	332	dump_string_field (di, "note", "global fini");
671116bf	333	if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
5a471c32	334	dump_string_field (di, "note", "pseudo tmpl");
74e1778a	335	}
	336	else
	337	{
71b1859a	338	tree virt = THUNK_VIRTUAL_OFFSET (t);
9031d10b	339
5a471c32	340	dump_string_field (di, "note", "thunk");
805e22b2	341	if (DECL_THIS_THUNK_P (t))
5a471c32	342	dump_string_field (di, "note", "this adjusting");
805e22b2	343	else
71b1859a	344	{
5a471c32	345	dump_string_field (di, "note", "result adjusting");
71b1859a	346	if (virt)
	347	virt = BINFO_VPTR_FIELD (virt);
	348	}
805e22b2	349	dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
71b1859a	350	if (virt)
fcb97e84	351	dump_int (di, "virt", tree_to_shwi (virt));
2b82dde2	352	dump_child ("fn", DECL_INITIAL (t));
74e1778a	353	}
ddea175e	354	break;
	355
	356	case NAMESPACE_DECL:
968eccb1	357	if (DECL_NAMESPACE_ALIAS (t))
968eccb1	358	dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
364c0b82	359	else if (!dump_flag (di, TDF_SLIM, t))
968eccb1	360	dump_child ("dcls", cp_namespace_decls (t));
ddea175e	361	break;
ddea175e	362
900f01f2	363	case TEMPLATE_DECL:
52d6ab53	364	dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
9b814097	365	dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
7806a559	366	dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
fa1e684b	367	dump_child ("prms", DECL_TEMPLATE_PARMS (t));
900f01f2	368	break;
900f01f2	369
ddea175e	370	case OVERLOAD:
7806a559	371	dump_child ("crnt", OVL_CURRENT (t));
7806a559	372	dump_child ("chan", OVL_CHAIN (t));
ddea175e	373	break;
ddea175e	374
c25509f2	375	case TRY_BLOCK:
ddea175e	376	dump_stmt (di, t);
c25509f2	377	if (CLEANUP_P (t))
5a471c32	378	dump_string_field (di, "note", "cleanup");
c25509f2	379	dump_child ("body", TRY_STMTS (t));
c25509f2	380	dump_child ("hdlr", TRY_HANDLERS (t));
ddea175e	381	break;
ddea175e	382
df4b504c	383	case EH_SPEC_BLOCK:
	384	dump_stmt (di, t);
	385	dump_child ("body", EH_SPEC_STMTS (t));
	386	dump_child ("raises", EH_SPEC_RAISES (t));
df4b504c	387	break;
df4b504c	388
c25509f2	389	case PTRMEM_CST:
	390	dump_child ("clas", PTRMEM_CST_CLASS (t));
	391	dump_child ("mbr", PTRMEM_CST_MEMBER (t));
ddea175e	392	break;
ddea175e	393
c25509f2	394	case THROW_EXPR:
	395	/* These nodes are unary, but do not have code class `1'. */
	396	dump_child ("op 0", TREE_OPERAND (t, 0));
ddea175e	397	break;
ddea175e	398
c25509f2	399	case AGGR_INIT_EXPR:
c2f47e15	400	{
	401	int i = 0;
	402	tree arg;
	403	aggr_init_expr_arg_iterator iter;
	404	dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
	405	dump_child ("fn", AGGR_INIT_EXPR_FN (t));
	406	FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
	407	{
	408	char buffer[32];
	409	sprintf (buffer, "%u", i);
	410	dump_child (buffer, arg);
	411	i++;
	412	}
	413	dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
	414	}
c25509f2	415	break;
9031d10b	416
e75beec7	417	case HANDLER:
e75beec7	418	dump_stmt (di, t);
6993fb0a	419	dump_child ("parm", HANDLER_PARMS (t));
e75beec7	420	dump_child ("body", HANDLER_BODY (t));
e75beec7	421	break;
e75beec7	422
df4b504c	423	case MUST_NOT_THROW_EXPR:
	424	dump_stmt (di, t);
	425	dump_child ("body", TREE_OPERAND (t, 0));
f9069149	426	dump_child ("cond", MUST_NOT_THROW_COND (t));
df4b504c	427	break;
df4b504c	428
85a363ce	429	case USING_STMT:
	430	dump_stmt (di, t);
	431	dump_child ("nmsp", USING_STMT_NAMESPACE (t));
85a363ce	432	break;
dddab69e	433
	434	case CLEANUP_STMT:
	435	dump_stmt (di, t);
	436	dump_child ("decl", CLEANUP_DECL (t));
	437	dump_child ("expr", CLEANUP_EXPR (t));
	438	dump_child ("body", CLEANUP_BODY (t));
dddab69e	439	break;
	440
	441	case IF_STMT:
	442	dump_stmt (di, t);
	443	dump_child ("cond", IF_COND (t));
	444	dump_child ("then", THEN_CLAUSE (t));
	445	dump_child ("else", ELSE_CLAUSE (t));
dddab69e	446	break;
dddab69e	447
e7911019	448	case BREAK_STMT:
	449	case CONTINUE_STMT:
	450	dump_stmt (di, t);
	451	break;
	452
	453	case DO_STMT:
	454	dump_stmt (di, t);
	455	dump_child ("body", DO_BODY (t));
	456	dump_child ("cond", DO_COND (t));
	457	break;
	458
	459	case FOR_STMT:
	460	dump_stmt (di, t);
	461	dump_child ("init", FOR_INIT_STMT (t));
	462	dump_child ("cond", FOR_COND (t));
	463	dump_child ("expr", FOR_EXPR (t));
	464	dump_child ("body", FOR_BODY (t));
	465	break;
	466
9dd72ec4	467	case RANGE_FOR_STMT:
	468	dump_stmt (di, t);
	469	dump_child ("decl", RANGE_FOR_DECL (t));
	470	dump_child ("expr", RANGE_FOR_EXPR (t));
	471	dump_child ("body", RANGE_FOR_BODY (t));
	472	break;
	473
e7911019	474	case SWITCH_STMT:
	475	dump_stmt (di, t);
	476	dump_child ("cond", SWITCH_STMT_COND (t));
	477	dump_child ("body", SWITCH_STMT_BODY (t));
	478	break;
	479
	480	case WHILE_STMT:
	481	dump_stmt (di, t);
	482	dump_child ("cond", WHILE_COND (t));
	483	dump_child ("body", WHILE_BODY (t));
	484	break;
	485
57f08f11	486	case STMT_EXPR:
	487	dump_child ("stmt", STMT_EXPR_STMT (t));
	488	break;
	489
7219fab5	490	case EXPR_STMT:
	491	dump_stmt (di, t);
	492	dump_child ("expr", EXPR_STMT_EXPR (t));
	493	break;
	494
ddea175e	495	default:
ddea175e	496	break;
	497	}
	498
d571f56f	499	return c_dump_tree (di, t);
ddea175e	500	}