aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.9/gcc/cp/dump.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.9/gcc/cp/dump.c')
-rw-r--r--gcc-4.9/gcc/cp/dump.c498
1 files changed, 498 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/cp/dump.c b/gcc-4.9/gcc/cp/dump.c
new file mode 100644
index 0000000..70b047a
--- /dev/null
+++ b/gcc-4.9/gcc/cp/dump.c
@@ -0,0 +1,498 @@
+/* Tree-dumping functionality for intermediate representation.
+ Copyright (C) 1999-2014 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;
+ }
+}
+
+/* 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);
+}