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