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