URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc2/] [gcc/] [cp/] [dump.c] - Rev 839
Go to most recent revision | Compare with Previous | Blame | View Log
/* Tree-dumping functionality for intermediate representation. Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc. Written by Mark Mitchell <mark@codesourcery.com> This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "tm.h" #include "tree.h" #include "cp-tree.h" #include "tree-dump.h" static void dump_access (dump_info_p, tree); static void dump_op (dump_info_p, tree); /* Dump a representation of the accessibility information associated with T. */ static void dump_access (dump_info_p di, tree t) { if (TREE_PROTECTED(t)) dump_string_field (di, "accs", "prot"); else if (TREE_PRIVATE(t)) dump_string_field (di, "accs", "priv"); else dump_string_field (di, "accs", "pub"); } /* Dump a representation of the specific operator for an overloaded operator associated with node t. */ static void dump_op (dump_info_p di, tree t) { switch (DECL_OVERLOADED_OPERATOR_P (t)) { case NEW_EXPR: dump_string (di, "new"); break; case VEC_NEW_EXPR: dump_string (di, "vecnew"); break; case DELETE_EXPR: dump_string (di, "delete"); break; case VEC_DELETE_EXPR: dump_string (di, "vecdelete"); break; case UNARY_PLUS_EXPR: dump_string (di, "pos"); break; case NEGATE_EXPR: dump_string (di, "neg"); break; case ADDR_EXPR: dump_string (di, "addr"); break; case INDIRECT_REF: dump_string(di, "deref"); break; case BIT_NOT_EXPR: dump_string(di, "not"); break; case TRUTH_NOT_EXPR: dump_string(di, "lnot"); break; case PREINCREMENT_EXPR: dump_string(di, "preinc"); break; case PREDECREMENT_EXPR: dump_string(di, "predec"); break; case PLUS_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "plusassign"); else dump_string(di, "plus"); break; case MINUS_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "minusassign"); else dump_string(di, "minus"); break; case MULT_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "multassign"); else dump_string (di, "mult"); break; case TRUNC_DIV_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "divassign"); else dump_string (di, "div"); break; case TRUNC_MOD_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "modassign"); else dump_string (di, "mod"); break; case BIT_AND_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "andassign"); else dump_string (di, "and"); break; case BIT_IOR_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "orassign"); else dump_string (di, "or"); break; case BIT_XOR_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "xorassign"); else dump_string (di, "xor"); break; case LSHIFT_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "lshiftassign"); else dump_string (di, "lshift"); break; case RSHIFT_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "rshiftassign"); else dump_string (di, "rshift"); break; case EQ_EXPR: dump_string (di, "eq"); break; case NE_EXPR: dump_string (di, "ne"); break; case LT_EXPR: dump_string (di, "lt"); break; case GT_EXPR: dump_string (di, "gt"); break; case LE_EXPR: dump_string (di, "le"); break; case GE_EXPR: dump_string (di, "ge"); break; case TRUTH_ANDIF_EXPR: dump_string (di, "land"); break; case TRUTH_ORIF_EXPR: dump_string (di, "lor"); break; case COMPOUND_EXPR: dump_string (di, "compound"); break; case MEMBER_REF: dump_string (di, "memref"); break; case COMPONENT_REF: dump_string (di, "ref"); break; case ARRAY_REF: dump_string (di, "subs"); break; case POSTINCREMENT_EXPR: dump_string (di, "postinc"); break; case POSTDECREMENT_EXPR: dump_string (di, "postdec"); break; case CALL_EXPR: dump_string (di, "call"); break; case NOP_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) dump_string (di, "assign"); break; default: break; } } bool cp_dump_tree (void* dump_info, tree t) { enum tree_code code; dump_info_p di = (dump_info_p) dump_info; /* Figure out what kind of node this is. */ code = TREE_CODE (t); if (DECL_P (t)) { if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus) dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t))); } switch (code) { case IDENTIFIER_NODE: if (IDENTIFIER_OPNAME_P (t)) { dump_string_field (di, "note", "operator"); return true; } else if (IDENTIFIER_TYPENAME_P (t)) { dump_child ("tynm", TREE_TYPE (t)); return true; } break; case OFFSET_TYPE: dump_string_field (di, "note", "ptrmem"); dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); return true; case RECORD_TYPE: if (TYPE_PTRMEMFUNC_P (t)) { dump_string_field (di, "note", "ptrmem"); dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); return true; } /* Fall through. */ case UNION_TYPE: /* Is it a type used as a base? */ if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t) && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t) { dump_child ("bfld", TYPE_CONTEXT (t)); return true; } if (! MAYBE_CLASS_TYPE_P (t)) break; dump_child ("vfld", TYPE_VFIELD (t)); if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t)) dump_string(di, "spec"); if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t)) { int i; tree binfo; tree base_binfo; for (binfo = TYPE_BINFO (t), i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) { dump_child ("base", BINFO_TYPE (base_binfo)); if (BINFO_VIRTUAL_P (base_binfo)) dump_string_field (di, "spec", "virt"); dump_access (di, base_binfo); } } break; case FIELD_DECL: dump_access (di, t); if (DECL_MUTABLE_P (t)) dump_string_field (di, "spec", "mutable"); break; case VAR_DECL: if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE) dump_access (di, t); if (TREE_STATIC (t) && !TREE_PUBLIC (t)) dump_string_field (di, "link", "static"); break; case FUNCTION_DECL: if (!DECL_THUNK_P (t)) { if (DECL_OVERLOADED_OPERATOR_P (t)) { dump_string_field (di, "note", "operator"); dump_op (di, t); } if (DECL_FUNCTION_MEMBER_P (t)) { dump_string_field (di, "note", "member"); dump_access (di, t); } if (DECL_PURE_VIRTUAL_P (t)) dump_string_field (di, "spec", "pure"); if (DECL_VIRTUAL_P (t)) dump_string_field (di, "spec", "virt"); if (DECL_CONSTRUCTOR_P (t)) dump_string_field (di, "note", "constructor"); if (DECL_DESTRUCTOR_P (t)) dump_string_field (di, "note", "destructor"); if (DECL_CONV_FN_P (t)) dump_string_field (di, "note", "conversion"); if (DECL_GLOBAL_CTOR_P (t)) dump_string_field (di, "note", "global init"); if (DECL_GLOBAL_DTOR_P (t)) dump_string_field (di, "note", "global fini"); if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)) dump_string_field (di, "note", "pseudo tmpl"); } else { tree virt = THUNK_VIRTUAL_OFFSET (t); dump_string_field (di, "note", "thunk"); if (DECL_THIS_THUNK_P (t)) dump_string_field (di, "note", "this adjusting"); else { dump_string_field (di, "note", "result adjusting"); if (virt) virt = BINFO_VPTR_FIELD (virt); } dump_int (di, "fixd", THUNK_FIXED_OFFSET (t)); if (virt) dump_int (di, "virt", tree_low_cst (virt, 0)); dump_child ("fn", DECL_INITIAL (t)); } break; case NAMESPACE_DECL: if (DECL_NAMESPACE_ALIAS (t)) dump_child ("alis", DECL_NAMESPACE_ALIAS (t)); else if (!dump_flag (di, TDF_SLIM, t)) dump_child ("dcls", cp_namespace_decls (t)); break; case TEMPLATE_DECL: dump_child ("rslt", DECL_TEMPLATE_RESULT (t)); dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t)); dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); dump_child ("prms", DECL_TEMPLATE_PARMS (t)); break; case OVERLOAD: dump_child ("crnt", OVL_CURRENT (t)); dump_child ("chan", OVL_CHAIN (t)); break; case TRY_BLOCK: dump_stmt (di, t); if (CLEANUP_P (t)) dump_string_field (di, "note", "cleanup"); dump_child ("body", TRY_STMTS (t)); dump_child ("hdlr", TRY_HANDLERS (t)); break; case EH_SPEC_BLOCK: dump_stmt (di, t); dump_child ("body", EH_SPEC_STMTS (t)); dump_child ("raises", EH_SPEC_RAISES (t)); break; case PTRMEM_CST: dump_child ("clas", PTRMEM_CST_CLASS (t)); dump_child ("mbr", PTRMEM_CST_MEMBER (t)); break; case THROW_EXPR: /* These nodes are unary, but do not have code class `1'. */ dump_child ("op 0", TREE_OPERAND (t, 0)); break; case AGGR_INIT_EXPR: { int i = 0; tree arg; aggr_init_expr_arg_iterator iter; dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t)); dump_child ("fn", AGGR_INIT_EXPR_FN (t)); FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t) { char buffer[32]; sprintf (buffer, "%u", i); dump_child (buffer, arg); i++; } dump_child ("decl", AGGR_INIT_EXPR_SLOT (t)); } break; case HANDLER: dump_stmt (di, t); dump_child ("parm", HANDLER_PARMS (t)); dump_child ("body", HANDLER_BODY (t)); break; case MUST_NOT_THROW_EXPR: dump_stmt (di, t); dump_child ("body", TREE_OPERAND (t, 0)); break; case USING_STMT: dump_stmt (di, t); dump_child ("nmsp", USING_STMT_NAMESPACE (t)); break; case CLEANUP_STMT: dump_stmt (di, t); dump_child ("decl", CLEANUP_DECL (t)); dump_child ("expr", CLEANUP_EXPR (t)); dump_child ("body", CLEANUP_BODY (t)); break; case IF_STMT: dump_stmt (di, t); dump_child ("cond", IF_COND (t)); dump_child ("then", THEN_CLAUSE (t)); dump_child ("else", ELSE_CLAUSE (t)); break; case BREAK_STMT: case CONTINUE_STMT: dump_stmt (di, t); break; case DO_STMT: dump_stmt (di, t); dump_child ("body", DO_BODY (t)); dump_child ("cond", DO_COND (t)); break; case FOR_STMT: dump_stmt (di, t); dump_child ("init", FOR_INIT_STMT (t)); dump_child ("cond", FOR_COND (t)); dump_child ("expr", FOR_EXPR (t)); dump_child ("body", FOR_BODY (t)); break; case 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); }
Go to most recent revision | Compare with Previous | Blame | View Log