gcc/cp/dump.c

   1 /* Tree-dumping functionality for intermediate representation.
   2    Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3    Written by Mark Mitchell <mark@codesourcery.com>
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  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
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "tree.h"
  25 #include "cp-tree.h"
  26 #include "tree-dump.h"
  27
  28 static void dump_access
  29   PARAMS ((dump_info_p, tree));
  30
  31 static void dump_op
  32   PARAMS ((dump_info_p, tree));
  33
  34 /* Dump a representation of the accessibility information associated
  35    with T.  */
  36
  37 static void
  38 dump_access (di, t)
  39      dump_info_p di;
  40      tree t;
  41 {
  42   if (TREE_PROTECTED(t))
  43     dump_string (di, "protected");
  44   else if (TREE_PRIVATE(t))
  45     dump_string (di, "private");
  46   else
  47     dump_string (di, "public");
  48 }
  49
  50 /* Dump a representation of the specific operator for an overloaded
  51    operator associated with node t.  */
  52
  53 static void
  54 dump_op (di, t)
  55      dump_info_p di;
  56      tree t;
  57 {
  58   switch (DECL_OVERLOADED_OPERATOR_P (t)) {
  59     case NEW_EXPR:
  60       dump_string (di, "new");
  61       break;
  62     case VEC_NEW_EXPR:
  63       dump_string (di, "vecnew");
  64       break;
  65     case DELETE_EXPR:
  66       dump_string (di, "delete");
  67       break;
  68     case VEC_DELETE_EXPR:
  69       dump_string (di, "vecdelete");
  70       break;
  71     case CONVERT_EXPR:
  72       dump_string (di, "pos");
  73       break;
  74     case NEGATE_EXPR:
  75       dump_string (di, "neg");
  76       break;
  77     case ADDR_EXPR:
  78       dump_string (di, "addr");
  79       break;
  80     case INDIRECT_REF:
  81       dump_string(di, "deref");
  82       break;
  83     case BIT_NOT_EXPR:
  84       dump_string(di, "not");
  85       break;
  86     case TRUTH_NOT_EXPR:
  87       dump_string(di, "lnot");
  88       break;
  89     case PREINCREMENT_EXPR:
  90       dump_string(di, "preinc");
  91       break;
  92     case PREDECREMENT_EXPR:
  93       dump_string(di, "predec");
  94       break;
  95     case PLUS_EXPR:
  96       if (DECL_ASSIGNMENT_OPERATOR_P (t))
  97         dump_string (di, "plusassign");
  98       else
  99         dump_string(di, "plus");
 100       break;
 101     case MINUS_EXPR:
 102       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 103         dump_string (di, "minusassign");
 104       else
 105         dump_string(di, "minus");
 106       break;
 107     case MULT_EXPR:
 108       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 109         dump_string (di, "multassign");
 110       else
 111         dump_string (di, "mult");
 112       break;
 113     case TRUNC_DIV_EXPR:
 114       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 115         dump_string (di, "divassign");
 116       else
 117         dump_string (di, "div");
 118       break;
 119     case TRUNC_MOD_EXPR:
 120       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 121          dump_string (di, "modassign");
 122       else
 123         dump_string (di, "mod");
 124       break;
 125     case BIT_AND_EXPR:
 126       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 127         dump_string (di, "andassign");
 128       else
 129         dump_string (di, "and");
 130       break;
 131     case BIT_IOR_EXPR:
 132       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 133         dump_string (di, "orassign");
 134       else
 135         dump_string (di, "or");
 136       break;
 137     case BIT_XOR_EXPR:
 138       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 139         dump_string (di, "xorassign");
 140       else
 141         dump_string (di, "xor");
 142       break;
 143     case LSHIFT_EXPR:
 144       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 145         dump_string (di, "lshiftassign");
 146       else
 147         dump_string (di, "lshift");
 148       break;
 149     case RSHIFT_EXPR:
 150       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 151         dump_string (di, "rshiftassign");
 152       else
 153         dump_string (di, "rshift");
 154       break;
 155     case EQ_EXPR:
 156       dump_string (di, "eq");
 157       break;
 158     case NE_EXPR:
 159       dump_string (di, "ne");
 160       break;
 161     case LT_EXPR:
 162       dump_string (di, "lt");
 163       break;
 164     case GT_EXPR:
 165       dump_string (di, "gt");
 166       break;
 167     case LE_EXPR:
 168       dump_string (di, "le");
 169       break;
 170     case GE_EXPR:
 171       dump_string (di, "ge");
 172       break;
 173     case TRUTH_ANDIF_EXPR:
 174       dump_string (di, "land");
 175       break;
 176     case TRUTH_ORIF_EXPR:
 177       dump_string (di, "lor");
 178       break;
 179     case COMPOUND_EXPR:
 180       dump_string (di, "compound");
 181       break;
 182     case MEMBER_REF:
 183       dump_string (di, "memref");
 184       break;
 185     case COMPONENT_REF:
 186       dump_string (di, "ref");
 187       break;
 188     case ARRAY_REF:
 189       dump_string (di, "subs");
 190       break;
 191     case POSTINCREMENT_EXPR:
 192       dump_string (di, "postinc");
 193       break;
 194     case POSTDECREMENT_EXPR:
 195       dump_string (di, "postdec");
 196       break;
 197     case CALL_EXPR:
 198       dump_string (di, "call");
 199       break;
 200     case NOP_EXPR:
 201       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 202         dump_string (di, "assign");
 203       break;
 204     default:
 205       break;
 206   }
 207 }
 208
 209 int
 210 cp_dump_tree (dump_info, t)
 211      void *dump_info;
 212      tree t;
 213 {
 214   enum tree_code code;
 215   dump_info_p di = (dump_info_p) dump_info;
 216
 217   /* Figure out what kind of node this is.  */
 218   code = TREE_CODE (t);
 219
 220   if (DECL_P (t))
 221     {
 222       if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
 223         dump_string (di, language_to_string (DECL_LANGUAGE (t), 0));
 224     }
 225
 226   switch (code)
 227     {
 228     case IDENTIFIER_NODE:
 229       if (IDENTIFIER_OPNAME_P (t))
 230         {
 231           dump_string (di, "operator");
 232           return 1;
 233         }
 234       else if (IDENTIFIER_TYPENAME_P (t))
 235         {
 236           dump_child ("tynm", TREE_TYPE (t));
 237           return 1;
 238         }
 239       else if (t == anonymous_namespace_name)
 240         {
 241           dump_string (di, "unnamed");
 242           return 1;
 243         }
 244       break;
 245
 246     case POINTER_TYPE:
 247       if (TYPE_PTRMEM_P (t))
 248         {
 249           dump_string (di, "ptrmem");
 250           dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
 251           dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
 252           return 1;
 253         }
 254       break;
 255
 256     case RECORD_TYPE:
 257     case UNION_TYPE:
 258       if (TYPE_PTRMEMFUNC_P (t))
 259         {
 260           dump_string (di, "ptrmem");
 261           dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
 262           dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
 263           return 1;
 264         }
 265
 266       dump_child ("vfld", TYPE_VFIELD (t));
 267       if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
 268         dump_string(di, "spec");
 269
 270       if (!dump_flag (di, TDF_SLIM, t))
 271         {
 272           int i;
 273
 274           for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
 275             {
 276               tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
 277               dump_child ("base", BINFO_TYPE (base_binfo));
 278               if (TREE_VIA_VIRTUAL (base_binfo))
 279                 dump_string (di, "virtual");
 280               dump_access (di, base_binfo);
 281             }
 282         }
 283       break;
 284
 285     case FIELD_DECL:
 286       dump_access (di, t);
 287       if (DECL_MUTABLE_P (t))
 288         dump_string(di, "mutable");
 289       break;
 290
 291     case VAR_DECL:
 292       if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
 293         dump_access (di, t);
 294       if (TREE_STATIC (t) && !TREE_PUBLIC (t))
 295         dump_string (di, "static");
 296       break;
 297
 298     case FUNCTION_DECL:
 299       if (!DECL_THUNK_P (t))
 300         {
 301           if (DECL_OVERLOADED_OPERATOR_P (t)) {
 302             dump_string (di, "operator");
 303             dump_op (di, t);
 304           }
 305           if (DECL_FUNCTION_MEMBER_P (t))
 306             {
 307               dump_string (di, "member");
 308               dump_access (di, t);
 309             }
 310           if (DECL_PURE_VIRTUAL_P (t))
 311             dump_string (di, "pure");
 312           if (DECL_VIRTUAL_P (t))
 313             dump_string (di, "virtual");
 314           if (DECL_CONSTRUCTOR_P (t))
 315             dump_string (di, "constructor");
 316           if (DECL_DESTRUCTOR_P (t))
 317             dump_string (di, "destructor");
 318           if (DECL_CONV_FN_P (t))
 319             dump_string (di, "conversion");
 320           if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
 321             {
 322               if (DECL_GLOBAL_CTOR_P (t))
 323                 dump_string (di, "global init");
 324               if (DECL_GLOBAL_DTOR_P (t))
 325                 dump_string (di, "global fini");
 326               dump_int (di, "prio", GLOBAL_INIT_PRIORITY (t));
 327             }
 328           if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
 329             dump_string (di, "pseudo tmpl");
 330         }
 331       else
 332         {
 333           dump_string (di, "thunk");
 334           dump_int (di, "dlta", THUNK_DELTA (t));
 335           dump_child ("vcll", THUNK_VCALL_OFFSET (t));
 336           dump_child ("fn", DECL_INITIAL (t));
 337         }
 338       break;
 339
 340     case NAMESPACE_DECL:
 341       if (DECL_NAMESPACE_ALIAS (t))
 342         dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
 343       else if (!dump_flag (di, TDF_SLIM, t))
 344         dump_child ("dcls", cp_namespace_decls (t));
 345       break;
 346
 347     case TEMPLATE_DECL:
 348       dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
 349       dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
 350       dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
 351       dump_child ("prms", DECL_TEMPLATE_PARMS (t));
 352       break;
 353
 354     case OVERLOAD:
 355       dump_child ("crnt", OVL_CURRENT (t));
 356       dump_child ("chan", OVL_CHAIN (t));
 357       break;
 358
 359     case TRY_BLOCK:
 360       dump_stmt (di, t);
 361       if (CLEANUP_P (t))
 362         dump_string (di, "cleanup");
 363       dump_child ("body", TRY_STMTS (t));
 364       dump_child ("hdlr", TRY_HANDLERS (t));
 365       dump_next_stmt (di, t);
 366       break;
 367
 368     case EH_SPEC_BLOCK:
 369       dump_stmt (di, t);
 370       dump_child ("body", EH_SPEC_STMTS (t));
 371       dump_child ("raises", EH_SPEC_RAISES (t));
 372       dump_next_stmt (di, t);
 373       break;
 374
 375     case PTRMEM_CST:
 376       dump_child ("clas", PTRMEM_CST_CLASS (t));
 377       dump_child ("mbr", PTRMEM_CST_MEMBER (t));
 378       break;
 379
 380     case THROW_EXPR:
 381       /* These nodes are unary, but do not have code class `1'.  */
 382       dump_child ("op 0", TREE_OPERAND (t, 0));
 383       break;
 384
 385     case AGGR_INIT_EXPR:
 386       dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
 387       dump_child ("fn", TREE_OPERAND (t, 0));
 388       dump_child ("args", TREE_OPERAND (t, 1));
 389       dump_child ("decl", TREE_OPERAND (t, 2));
 390       break;
 391
 392     case HANDLER:
 393       dump_stmt (di, t);
 394       dump_child ("parm", HANDLER_PARMS (t));
 395       dump_child ("body", HANDLER_BODY (t));
 396       dump_next_stmt (di, t);
 397       break;
 398
 399     case MUST_NOT_THROW_EXPR:
 400       dump_stmt (di, t);
 401       dump_child ("body", TREE_OPERAND (t, 0));
 402       dump_next_stmt (di, t);
 403       break;
 404
 405     case USING_STMT:
 406       dump_stmt (di, t);
 407       dump_child ("nmsp", USING_STMT_NAMESPACE (t));
 408       dump_next_stmt (di, t);
 409       break;
 410
 411     default:
 412       break;
 413     }
 414
 415   return c_dump_tree (di, t);
 416 }