/* Tree-dumping functionality for intermediate representation.
- Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
Free Software Foundation, Inc.
Written by Mark Mitchell <mark@codesourcery.com>
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 2, or (at your option)
+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,
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 COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
dump_access (dump_info_p di, tree t)
{
if (TREE_PROTECTED(t))
- dump_string (di, "protected");
+ dump_string_field (di, "accs", "prot");
else if (TREE_PRIVATE(t))
- dump_string (di, "private");
+ dump_string_field (di, "accs", "priv");
else
- dump_string (di, "public");
+ dump_string_field (di, "accs", "pub");
}
/* Dump a representation of the specific operator for an overloaded
case VEC_DELETE_EXPR:
dump_string (di, "vecdelete");
break;
- case CONVERT_EXPR:
+ case UNARY_PLUS_EXPR:
dump_string (di, "pos");
break;
case NEGATE_EXPR:
break;
case PLUS_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "plusassign");
+ dump_string (di, "plusassign");
else
- dump_string(di, "plus");
+ dump_string(di, "plus");
break;
case MINUS_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "minusassign");
+ dump_string (di, "minusassign");
else
- dump_string(di, "minus");
+ dump_string(di, "minus");
break;
case MULT_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "multassign");
+ dump_string (di, "multassign");
else
- dump_string (di, "mult");
+ dump_string (di, "mult");
break;
case TRUNC_DIV_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "divassign");
+ dump_string (di, "divassign");
else
- dump_string (di, "div");
+ dump_string (di, "div");
break;
case TRUNC_MOD_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "modassign");
+ dump_string (di, "modassign");
else
- dump_string (di, "mod");
+ dump_string (di, "mod");
break;
case BIT_AND_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "andassign");
+ dump_string (di, "andassign");
else
- dump_string (di, "and");
+ dump_string (di, "and");
break;
case BIT_IOR_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "orassign");
+ dump_string (di, "orassign");
else
- dump_string (di, "or");
+ dump_string (di, "or");
break;
case BIT_XOR_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "xorassign");
+ dump_string (di, "xorassign");
else
- dump_string (di, "xor");
+ dump_string (di, "xor");
break;
case LSHIFT_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "lshiftassign");
+ dump_string (di, "lshiftassign");
else
- dump_string (di, "lshift");
+ dump_string (di, "lshift");
break;
case RSHIFT_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "rshiftassign");
+ dump_string (di, "rshiftassign");
else
- dump_string (di, "rshift");
+ dump_string (di, "rshift");
break;
case EQ_EXPR:
dump_string (di, "eq");
dump_string (di, "subs");
break;
case POSTINCREMENT_EXPR:
- dump_string (di, "postinc");
+ dump_string (di, "postinc");
break;
case POSTDECREMENT_EXPR:
dump_string (di, "postdec");
break;
case NOP_EXPR:
if (DECL_ASSIGNMENT_OPERATOR_P (t))
- dump_string (di, "assign");
+ dump_string (di, "assign");
break;
default:
break;
if (DECL_P (t))
{
if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
- dump_string (di, language_to_string (DECL_LANGUAGE (t)));
+ dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
}
switch (code)
case IDENTIFIER_NODE:
if (IDENTIFIER_OPNAME_P (t))
{
- dump_string (di, "operator");
+ dump_string_field (di, "note", "operator");
return true;
}
else if (IDENTIFIER_TYPENAME_P (t))
break;
case OFFSET_TYPE:
- dump_string (di, "ptrmem");
+ 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 (di, "ptrmem");
+ 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;
dump_child ("bfld", TYPE_CONTEXT (t));
return true;
}
-
- if (! IS_AGGR_TYPE (t))
+
+ if (! MAYBE_CLASS_TYPE_P (t))
break;
dump_child ("vfld", TYPE_VFIELD (t));
if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
- dump_string(di, "spec");
+ 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 (di, "virtual");
+ if (BINFO_VIRTUAL_P (base_binfo))
+ dump_string_field (di, "spec", "virt");
dump_access (di, base_binfo);
}
}
case FIELD_DECL:
dump_access (di, t);
if (DECL_MUTABLE_P (t))
- dump_string(di, "mutable");
+ dump_string_field (di, "spec", "mutable");
break;
case VAR_DECL:
if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
- dump_access (di, t);
+ dump_access (di, t);
if (TREE_STATIC (t) && !TREE_PUBLIC (t))
- dump_string (di, "static");
- break;
+ dump_string_field (di, "link", "static");
+ break;
case FUNCTION_DECL:
if (!DECL_THUNK_P (t))
{
- if (DECL_OVERLOADED_OPERATOR_P (t)) {
- dump_string (di, "operator");
- dump_op (di, t);
- }
- if (DECL_FUNCTION_MEMBER_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 (di, "member");
+ dump_string_field (di, "note", "member");
dump_access (di, t);
}
- if (DECL_PURE_VIRTUAL_P (t))
- dump_string (di, "pure");
- if (DECL_VIRTUAL_P (t))
- dump_string (di, "virtual");
+ 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 (di, "constructor");
+ dump_string_field (di, "note", "constructor");
if (DECL_DESTRUCTOR_P (t))
- dump_string (di, "destructor");
+ dump_string_field (di, "note", "destructor");
if (DECL_CONV_FN_P (t))
- dump_string (di, "conversion");
+ dump_string_field (di, "note", "conversion");
if (DECL_GLOBAL_CTOR_P (t))
- dump_string (di, "global init");
+ dump_string_field (di, "note", "global init");
if (DECL_GLOBAL_DTOR_P (t))
- dump_string (di, "global fini");
+ dump_string_field (di, "note", "global fini");
if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
- dump_string (di, "pseudo tmpl");
+ dump_string_field (di, "note", "pseudo tmpl");
}
else
{
tree virt = THUNK_VIRTUAL_OFFSET (t);
-
- dump_string (di, "thunk");
+
+ dump_string_field (di, "note", "thunk");
if (DECL_THIS_THUNK_P (t))
- dump_string (di, "this adjusting");
+ dump_string_field (di, "note", "this adjusting");
else
{
- dump_string (di, "result adjusting");
+ dump_string_field (di, "note", "result adjusting");
if (virt)
virt = BINFO_VPTR_FIELD (virt);
}
case TRY_BLOCK:
dump_stmt (di, t);
if (CLEANUP_P (t))
- dump_string (di, "cleanup");
+ dump_string_field (di, "note", "cleanup");
dump_child ("body", TRY_STMTS (t));
dump_child ("hdlr", TRY_HANDLERS (t));
break;
break;
case AGGR_INIT_EXPR:
- dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
- dump_child ("fn", TREE_OPERAND (t, 0));
- dump_child ("args", TREE_OPERAND (t, 1));
- dump_child ("decl", TREE_OPERAND (t, 2));
+ {
+ 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", 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;
}
OSDN Git Service
