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