gcc/cp/dump.c

   1 /* Tree-dumping functionality for intermediate representation.
   2    Copyright (C) 1999-2015 Free Software Foundation, Inc.
   3    Written by Mark Mitchell <mark@codesourcery.com>
   4
   5 This file is part of GCC.
   6
   7 GCC 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 3, or (at your option)
  10 any later version.
  11
  12 GCC 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 GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "alias.h"
  26 #include "symtab.h"
  27 #include "tree.h"
  28 #include "cp-tree.h"
  29 #include "tree-dump.h"
  30
  31 static void dump_access (dump_info_p, tree);
  32
  33 static void dump_op (dump_info_p, tree);
  34
  35 /* Dump a representation of the accessibility information associated
  36    with T.  */
  37
  38 static void
  39 dump_access (dump_info_p di, tree t)
  40 {
  41   if (TREE_PROTECTED(t))
  42     dump_string_field (di, "accs", "prot");
  43   else if (TREE_PRIVATE(t))
  44     dump_string_field (di, "accs", "priv");
  45   else
  46     dump_string_field (di, "accs", "pub");
  47 }
  48
  49 /* Dump a representation of the specific operator for an overloaded
  50    operator associated with node t.  */
  51
  52 static void
  53 dump_op (dump_info_p di, tree t)
  54 {
  55   switch (DECL_OVERLOADED_OPERATOR_P (t)) {
  56     case NEW_EXPR:
  57       dump_string (di, "new");
  58       break;
  59     case VEC_NEW_EXPR:
  60       dump_string (di, "vecnew");
  61       break;
  62     case DELETE_EXPR:
  63       dump_string (di, "delete");
  64       break;
  65     case VEC_DELETE_EXPR:
  66       dump_string (di, "vecdelete");
  67       break;
  68     case UNARY_PLUS_EXPR:
  69       dump_string (di, "pos");
  70       break;
  71     case NEGATE_EXPR:
  72       dump_string (di, "neg");
  73       break;
  74     case ADDR_EXPR:
  75       dump_string (di, "addr");
  76       break;
  77     case INDIRECT_REF:
  78       dump_string(di, "deref");
  79       break;
  80     case BIT_NOT_EXPR:
  81       dump_string(di, "not");
  82       break;
  83     case TRUTH_NOT_EXPR:
  84       dump_string(di, "lnot");
  85       break;
  86     case PREINCREMENT_EXPR:
  87       dump_string(di, "preinc");
  88       break;
  89     case PREDECREMENT_EXPR:
  90       dump_string(di, "predec");
  91       break;
  92     case PLUS_EXPR:
  93       if (DECL_ASSIGNMENT_OPERATOR_P (t))
  94         dump_string (di, "plusassign");
  95       else
  96         dump_string(di, "plus");
  97       break;
  98     case MINUS_EXPR:
  99       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 100         dump_string (di, "minusassign");
 101       else
 102         dump_string(di, "minus");
 103       break;
 104     case MULT_EXPR:
 105       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 106         dump_string (di, "multassign");
 107       else
 108         dump_string (di, "mult");
 109       break;
 110     case TRUNC_DIV_EXPR:
 111       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 112         dump_string (di, "divassign");
 113       else
 114         dump_string (di, "div");
 115       break;
 116     case TRUNC_MOD_EXPR:
 117       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 118          dump_string (di, "modassign");
 119       else
 120         dump_string (di, "mod");
 121       break;
 122     case BIT_AND_EXPR:
 123       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 124         dump_string (di, "andassign");
 125       else
 126         dump_string (di, "and");
 127       break;
 128     case BIT_IOR_EXPR:
 129       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 130         dump_string (di, "orassign");
 131       else
 132         dump_string (di, "or");
 133       break;
 134     case BIT_XOR_EXPR:
 135       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 136         dump_string (di, "xorassign");
 137       else
 138         dump_string (di, "xor");
 139       break;
 140     case LSHIFT_EXPR:
 141       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 142         dump_string (di, "lshiftassign");
 143       else
 144         dump_string (di, "lshift");
 145       break;
 146     case RSHIFT_EXPR:
 147       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 148         dump_string (di, "rshiftassign");
 149       else
 150         dump_string (di, "rshift");
 151       break;
 152     case EQ_EXPR:
 153       dump_string (di, "eq");
 154       break;
 155     case NE_EXPR:
 156       dump_string (di, "ne");
 157       break;
 158     case LT_EXPR:
 159       dump_string (di, "lt");
 160       break;
 161     case GT_EXPR:
 162       dump_string (di, "gt");
 163       break;
 164     case LE_EXPR:
 165       dump_string (di, "le");
 166       break;
 167     case GE_EXPR:
 168       dump_string (di, "ge");
 169       break;
 170     case TRUTH_ANDIF_EXPR:
 171       dump_string (di, "land");
 172       break;
 173     case TRUTH_ORIF_EXPR:
 174       dump_string (di, "lor");
 175       break;
 176     case COMPOUND_EXPR:
 177       dump_string (di, "compound");
 178       break;
 179     case MEMBER_REF:
 180       dump_string (di, "memref");
 181       break;
 182     case COMPONENT_REF:
 183       dump_string (di, "ref");
 184       break;
 185     case ARRAY_REF:
 186       dump_string (di, "subs");
 187       break;
 188     case POSTINCREMENT_EXPR:
 189       dump_string (di, "postinc");
 190       break;
 191     case POSTDECREMENT_EXPR:
 192       dump_string (di, "postdec");
 193       break;
 194     case CALL_EXPR:
 195       dump_string (di, "call");
 196       break;
 197     case NOP_EXPR:
 198       if (DECL_ASSIGNMENT_OPERATOR_P (t))
 199         dump_string (di, "assign");
 200       break;
 201     default:
 202       break;
 203   }
 204 }
 205
 206 /* Dump information common to statements from STMT.  */
 207
 208 static void
 209 dump_stmt (dump_info_p di, const_tree t)
 210 {
 211   if (EXPR_HAS_LOCATION (t))
 212     dump_int (di, "line", EXPR_LINENO (t));
 213 }
 214
 215 bool
 216 cp_dump_tree (void* dump_info, tree t)
 217 {
 218   enum tree_code code;
 219   dump_info_p di = (dump_info_p) dump_info;
 220
 221   /* Figure out what kind of node this is.  */
 222   code = TREE_CODE (t);
 223
 224   if (DECL_P (t))
 225     {
 226       if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus)
 227         dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t)));
 228     }
 229
 230   switch (code)
 231     {
 232     case IDENTIFIER_NODE:
 233       if (IDENTIFIER_OPNAME_P (t))
 234         {
 235           dump_string_field (di, "note", "operator");
 236           return true;
 237         }
 238       else if (IDENTIFIER_TYPENAME_P (t))
 239         {
 240           dump_child ("tynm", TREE_TYPE (t));
 241           return true;
 242         }
 243       break;
 244
 245     case OFFSET_TYPE:
 246       dump_string_field (di, "note", "ptrmem");
 247       dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
 248       dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
 249       return true;
 250
 251     case RECORD_TYPE:
 252       if (TYPE_PTRMEMFUNC_P (t))
 253         {
 254           dump_string_field (di, "note", "ptrmem");
 255           dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t));
 256           dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t));
 257           return true;
 258         }
 259       /* Fall through.  */
 260
 261     case UNION_TYPE:
 262       /* Is it a type used as a base? */
 263       if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t)
 264           && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)
 265         {
 266           dump_child ("bfld", TYPE_CONTEXT (t));
 267           return true;
 268         }
 269
 270       if (! MAYBE_CLASS_TYPE_P (t))
 271         break;
 272
 273       dump_child ("vfld", TYPE_VFIELD (t));
 274       if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t))
 275         dump_string(di, "spec");
 276
 277       if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t))
 278         {
 279           int i;
 280           tree binfo;
 281           tree base_binfo;
 282
 283           for (binfo = TYPE_BINFO (t), i = 0;
 284                BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
 285             {
 286               dump_child ("base", BINFO_TYPE (base_binfo));
 287               if (BINFO_VIRTUAL_P (base_binfo))
 288                 dump_string_field (di, "spec", "virt");
 289               dump_access (di, base_binfo);
 290             }
 291         }
 292       break;
 293
 294     case FIELD_DECL:
 295       dump_access (di, t);
 296       if (DECL_MUTABLE_P (t))
 297         dump_string_field (di, "spec", "mutable");
 298       break;
 299
 300     case VAR_DECL:
 301       if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE)
 302         dump_access (di, t);
 303       if (TREE_STATIC (t) && !TREE_PUBLIC (t))
 304         dump_string_field (di, "link", "static");
 305       break;
 306
 307     case FUNCTION_DECL:
 308       if (!DECL_THUNK_P (t))
 309         {
 310           if (DECL_OVERLOADED_OPERATOR_P (t)) {
 311             dump_string_field (di, "note", "operator");
 312             dump_op (di, t);
 313           }
 314           if (DECL_FUNCTION_MEMBER_P (t))
 315             {
 316               dump_string_field (di, "note", "member");
 317               dump_access (di, t);
 318             }
 319           if (DECL_PURE_VIRTUAL_P (t))
 320             dump_string_field (di, "spec", "pure");
 321           if (DECL_VIRTUAL_P (t))
 322             dump_string_field (di, "spec", "virt");
 323           if (DECL_CONSTRUCTOR_P (t))
 324             dump_string_field (di, "note", "constructor");
 325           if (DECL_DESTRUCTOR_P (t))
 326             dump_string_field (di, "note", "destructor");
 327           if (DECL_CONV_FN_P (t))
 328             dump_string_field (di, "note", "conversion");
 329           if (DECL_GLOBAL_CTOR_P (t))
 330             dump_string_field (di, "note", "global init");
 331           if (DECL_GLOBAL_DTOR_P (t))
 332             dump_string_field (di, "note", "global fini");
 333           if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t))
 334             dump_string_field (di, "note", "pseudo tmpl");
 335         }
 336       else
 337         {
 338           tree virt = THUNK_VIRTUAL_OFFSET (t);
 339
 340           dump_string_field (di, "note", "thunk");
 341           if (DECL_THIS_THUNK_P (t))
 342             dump_string_field (di, "note", "this adjusting");
 343           else
 344             {
 345               dump_string_field (di, "note", "result adjusting");
 346               if (virt)
 347                 virt = BINFO_VPTR_FIELD (virt);
 348             }
 349           dump_int (di, "fixd", THUNK_FIXED_OFFSET (t));
 350           if (virt)
 351             dump_int (di, "virt", tree_to_shwi (virt));
 352           dump_child ("fn", DECL_INITIAL (t));
 353         }
 354       break;
 355
 356     case NAMESPACE_DECL:
 357       if (DECL_NAMESPACE_ALIAS (t))
 358         dump_child ("alis", DECL_NAMESPACE_ALIAS (t));
 359       else if (!dump_flag (di, TDF_SLIM, t))
 360         dump_child ("dcls", cp_namespace_decls (t));
 361       break;
 362
 363     case TEMPLATE_DECL:
 364       dump_child ("rslt", DECL_TEMPLATE_RESULT (t));
 365       dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t));
 366       dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t));
 367       dump_child ("prms", DECL_TEMPLATE_PARMS (t));
 368       break;
 369
 370     case OVERLOAD:
 371       dump_child ("crnt", OVL_CURRENT (t));
 372       dump_child ("chan", OVL_CHAIN (t));
 373       break;
 374
 375     case TRY_BLOCK:
 376       dump_stmt (di, t);
 377       if (CLEANUP_P (t))
 378         dump_string_field (di, "note", "cleanup");
 379       dump_child ("body", TRY_STMTS (t));
 380       dump_child ("hdlr", TRY_HANDLERS (t));
 381       break;
 382
 383     case EH_SPEC_BLOCK:
 384       dump_stmt (di, t);
 385       dump_child ("body", EH_SPEC_STMTS (t));
 386       dump_child ("raises", EH_SPEC_RAISES (t));
 387       break;
 388
 389     case PTRMEM_CST:
 390       dump_child ("clas", PTRMEM_CST_CLASS (t));
 391       dump_child ("mbr", PTRMEM_CST_MEMBER (t));
 392       break;
 393
 394     case THROW_EXPR:
 395       /* These nodes are unary, but do not have code class `1'.  */
 396       dump_child ("op 0", TREE_OPERAND (t, 0));
 397       break;
 398
 399     case AGGR_INIT_EXPR:
 400       {
 401         int i = 0;
 402         tree arg;
 403         aggr_init_expr_arg_iterator iter;
 404         dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t));
 405         dump_child ("fn", AGGR_INIT_EXPR_FN (t));
 406         FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
 407           {
 408             char buffer[32];
 409             sprintf (buffer, "%u", i);
 410             dump_child (buffer, arg);
 411             i++;
 412           }
 413         dump_child ("decl", AGGR_INIT_EXPR_SLOT (t));
 414       }
 415       break;
 416
 417     case HANDLER:
 418       dump_stmt (di, t);
 419       dump_child ("parm", HANDLER_PARMS (t));
 420       dump_child ("body", HANDLER_BODY (t));
 421       break;
 422
 423     case MUST_NOT_THROW_EXPR:
 424       dump_stmt (di, t);
 425       dump_child ("body", TREE_OPERAND (t, 0));
 426       dump_child ("cond", MUST_NOT_THROW_COND (t));
 427       break;
 428
 429     case USING_STMT:
 430       dump_stmt (di, t);
 431       dump_child ("nmsp", USING_STMT_NAMESPACE (t));
 432       break;
 433
 434     case CLEANUP_STMT:
 435       dump_stmt (di, t);
 436       dump_child ("decl", CLEANUP_DECL (t));
 437       dump_child ("expr", CLEANUP_EXPR (t));
 438       dump_child ("body", CLEANUP_BODY (t));
 439       break;
 440
 441     case IF_STMT:
 442       dump_stmt (di, t);
 443       dump_child ("cond", IF_COND (t));
 444       dump_child ("then", THEN_CLAUSE (t));
 445       dump_child ("else", ELSE_CLAUSE (t));
 446       break;
 447
 448     case BREAK_STMT:
 449     case CONTINUE_STMT:
 450       dump_stmt (di, t);
 451       break;
 452
 453     case DO_STMT:
 454       dump_stmt (di, t);
 455       dump_child ("body", DO_BODY (t));
 456       dump_child ("cond", DO_COND (t));
 457       break;
 458
 459     case FOR_STMT:
 460       dump_stmt (di, t);
 461       dump_child ("init", FOR_INIT_STMT (t));
 462       dump_child ("cond", FOR_COND (t));
 463       dump_child ("expr", FOR_EXPR (t));
 464       dump_child ("body", FOR_BODY (t));
 465       break;
 466
 467     case RANGE_FOR_STMT:
 468       dump_stmt (di, t);
 469       dump_child ("decl", RANGE_FOR_DECL (t));
 470       dump_child ("expr", RANGE_FOR_EXPR (t));
 471       dump_child ("body", RANGE_FOR_BODY (t));
 472       break;
 473
 474     case SWITCH_STMT:
 475       dump_stmt (di, t);
 476       dump_child ("cond", SWITCH_STMT_COND (t));
 477       dump_child ("body", SWITCH_STMT_BODY (t));
 478       break;
 479
 480     case WHILE_STMT:
 481       dump_stmt (di, t);
 482       dump_child ("cond", WHILE_COND (t));
 483       dump_child ("body", WHILE_BODY (t));
 484       break;
 485
 486     case STMT_EXPR:
 487       dump_child ("stmt", STMT_EXPR_STMT (t));
 488       break;
 489
 490     case EXPR_STMT:
 491       dump_stmt (di, t);
 492       dump_child ("expr", EXPR_STMT_EXPR (t));
 493       break;
 494
 495     default:
 496       break;
 497     }
 498
 499   return c_dump_tree (di, t);
 500 }