X-Git-Url: https://oss.titaniummirror.com/gitweb?a=blobdiff_plain;f=gcc%2Fcp%2Fdump.c;fp=gcc%2Fcp%2Fdump.c;h=5ca10fca2a1167e10ae88d99a8262be3632cdc4a;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=6dd60baf73be26581b34c727ff32677a2a5c042d;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git diff --git a/gcc/cp/dump.c b/gcc/cp/dump.c index 6dd60baf..5ca10fca 100644 --- a/gcc/cp/dump.c +++ b/gcc/cp/dump.c @@ -1,60 +1,55 @@ /* Tree-dumping functionality for intermediate representation. - Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc. + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008 + Free Software Foundation, Inc. Written by Mark Mitchell -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify +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. -GNU CC is distributed in the hope that it will be useful, +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 GNU CC; 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 +. */ #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 - PARAMS ((dump_info_p, tree)); +static void dump_access (dump_info_p, tree); -static void dump_op - PARAMS ((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 (di, t) - dump_info_p di; - tree t; +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 - operator associated with node t. -*/ + operator associated with node t. */ static void -dump_op (di, t) - dump_info_p di; - tree t; +dump_op (dump_info_p di, tree t) { switch (DECL_OVERLOADED_OPERATOR_P (t)) { case NEW_EXPR: @@ -69,7 +64,7 @@ dump_op (di, t) case VEC_DELETE_EXPR: dump_string (di, "vecdelete"); break; - case CONVERT_EXPR: + case UNARY_PLUS_EXPR: dump_string (di, "pos"); break; case NEGATE_EXPR: @@ -95,63 +90,63 @@ dump_op (di, t) 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"); @@ -190,7 +185,7 @@ dump_op (di, t) dump_string (di, "subs"); break; case POSTINCREMENT_EXPR: - dump_string (di, "postinc"); + dump_string (di, "postinc"); break; case POSTDECREMENT_EXPR: dump_string (di, "postdec"); @@ -200,17 +195,15 @@ dump_op (di, t) break; case NOP_EXPR: if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "assign"); + dump_string (di, "assign"); break; default: break; } } -int -cp_dump_tree (dump_info, t) - void *dump_info; - tree t; +bool +cp_dump_tree (void* dump_info, tree t) { enum tree_code code; dump_info_p di = (dump_info_p) dump_info; @@ -221,7 +214,7 @@ cp_dump_tree (dump_info, t) if (DECL_P (t)) { if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus) - dump_string (di, language_to_string (DECL_LANGUAGE (t), 0)); + dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t))); } switch (code) @@ -229,55 +222,60 @@ cp_dump_tree (dump_info, t) case IDENTIFIER_NODE: if (IDENTIFIER_OPNAME_P (t)) { - dump_string (di, "operator"); - return 1; + dump_string_field (di, "note", "operator"); + return true; } else if (IDENTIFIER_TYPENAME_P (t)) { dump_child ("tynm", TREE_TYPE (t)); - return 1; - } - else if (t == anonymous_namespace_name) - { - dump_string (di, "unnamed"); - return 1; + return true; } break; - case POINTER_TYPE: - if (TYPE_PTRMEM_P (t)) + 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 (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 1; + return true; } - break; + /* Fall through. */ - case RECORD_TYPE: case UNION_TYPE: - if (TYPE_PTRMEMFUNC_P (t)) + /* 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_string (di, "ptrmem"); - dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); - dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); - return 1; + 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"); + dump_string(di, "spec"); - if (!dump_flag (di, TDF_SLIM, t)) + if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t)) { int i; - - for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i) + tree binfo; + tree base_binfo; + + for (binfo = TYPE_BINFO (t), i = 0; + BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) { - tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i); dump_child ("base", BINFO_TYPE (base_binfo)); - if (TREE_VIA_VIRTUAL (base_binfo)) - dump_string (di, "virtual"); + if (BINFO_VIRTUAL_P (base_binfo)) + dump_string_field (di, "spec", "virt"); dump_access (di, base_binfo); } } @@ -286,54 +284,61 @@ cp_dump_tree (dump_info, t) 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"); - if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t)) - { - if (DECL_GLOBAL_CTOR_P (t)) - dump_string (di, "global init"); - if (DECL_GLOBAL_DTOR_P (t)) - dump_string (di, "global fini"); - dump_int (di, "prio", GLOBAL_INIT_PRIORITY (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 (di, "pseudo tmpl"); + dump_string_field (di, "note", "pseudo tmpl"); } else { - dump_string (di, "thunk"); - dump_int (di, "dlta", THUNK_DELTA (t)); - dump_child ("vcll", THUNK_VCALL_OFFSET (t)); + 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; @@ -360,17 +365,15 @@ cp_dump_tree (dump_info, t) 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)); - dump_next_stmt (di, t); break; case EH_SPEC_BLOCK: dump_stmt (di, t); dump_child ("body", EH_SPEC_STMTS (t)); dump_child ("raises", EH_SPEC_RAISES (t)); - dump_next_stmt (di, t); break; case PTRMEM_CST: @@ -384,50 +387,96 @@ cp_dump_tree (dump_info, t) 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)); - break; - - case CTOR_STMT: - dump_stmt (di, t); - if (CTOR_BEGIN_P (t)) - dump_string (di, "begn"); - else - dump_string (di, "end"); - dump_next_stmt (di, t); + { + 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)); - dump_next_stmt (di, t); break; case MUST_NOT_THROW_EXPR: dump_stmt (di, t); dump_child ("body", TREE_OPERAND (t, 0)); - dump_next_stmt (di, t); break; - case SUBOBJECT: + case USING_STMT: dump_stmt (di, t); - dump_child ("clnp", TREE_OPERAND (t, 0)); - dump_next_stmt (di, t); + dump_child ("nmsp", USING_STMT_NAMESPACE (t)); break; - case USING_STMT: + case CLEANUP_STMT: dump_stmt (di, t); - dump_child ("nmsp", USING_STMT_NAMESPACE (t)); - dump_next_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 0; + return c_dump_tree (di, t); } -