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