1 /* Tree-dumping functionality for intermediate representation. 2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010 3 Free Software Foundation, Inc. 4 Written by Mark Mitchell <mark@codesourcery.com> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GCC is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 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 (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 bool 206 cp_dump_tree (void* dump_info, tree t) 207 { 208 enum tree_code code; 209 dump_info_p di = (dump_info_p) dump_info; 210 211 /* Figure out what kind of node this is. */ 212 code = TREE_CODE (t); 213 214 if (DECL_P (t)) 215 { 216 if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus) 217 dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t))); 218 } 219 220 switch (code) 221 { 222 case IDENTIFIER_NODE: 223 if (IDENTIFIER_OPNAME_P (t)) 224 { 225 dump_string_field (di, "note", "operator"); 226 return true; 227 } 228 else if (IDENTIFIER_TYPENAME_P (t)) 229 { 230 dump_child ("tynm", TREE_TYPE (t)); 231 return true; 232 } 233 break; 234 235 case OFFSET_TYPE: 236 dump_string_field (di, "note", "ptrmem"); 237 dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); 238 dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); 239 return true; 240 241 case RECORD_TYPE: 242 if (TYPE_PTRMEMFUNC_P (t)) 243 { 244 dump_string_field (di, "note", "ptrmem"); 245 dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); 246 dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); 247 return true; 248 } 249 /* Fall through. */ 250 251 case UNION_TYPE: 252 /* Is it a type used as a base? */ 253 if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t) 254 && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t) 255 { 256 dump_child ("bfld", TYPE_CONTEXT (t)); 257 return true; 258 } 259 260 if (! MAYBE_CLASS_TYPE_P (t)) 261 break; 262 263 dump_child ("vfld", TYPE_VFIELD (t)); 264 if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t)) 265 dump_string(di, "spec"); 266 267 if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t)) 268 { 269 int i; 270 tree binfo; 271 tree base_binfo; 272 273 for (binfo = TYPE_BINFO (t), i = 0; 274 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 275 { 276 dump_child ("base", BINFO_TYPE (base_binfo)); 277 if (BINFO_VIRTUAL_P (base_binfo)) 278 dump_string_field (di, "spec", "virt"); 279 dump_access (di, base_binfo); 280 } 281 } 282 break; 283 284 case FIELD_DECL: 285 dump_access (di, t); 286 if (DECL_MUTABLE_P (t)) 287 dump_string_field (di, "spec", "mutable"); 288 break; 289 290 case VAR_DECL: 291 if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE) 292 dump_access (di, t); 293 if (TREE_STATIC (t) && !TREE_PUBLIC (t)) 294 dump_string_field (di, "link", "static"); 295 break; 296 297 case FUNCTION_DECL: 298 if (!DECL_THUNK_P (t)) 299 { 300 if (DECL_OVERLOADED_OPERATOR_P (t)) { 301 dump_string_field (di, "note", "operator"); 302 dump_op (di, t); 303 } 304 if (DECL_FUNCTION_MEMBER_P (t)) 305 { 306 dump_string_field (di, "note", "member"); 307 dump_access (di, t); 308 } 309 if (DECL_PURE_VIRTUAL_P (t)) 310 dump_string_field (di, "spec", "pure"); 311 if (DECL_VIRTUAL_P (t)) 312 dump_string_field (di, "spec", "virt"); 313 if (DECL_CONSTRUCTOR_P (t)) 314 dump_string_field (di, "note", "constructor"); 315 if (DECL_DESTRUCTOR_P (t)) 316 dump_string_field (di, "note", "destructor"); 317 if (DECL_CONV_FN_P (t)) 318 dump_string_field (di, "note", "conversion"); 319 if (DECL_GLOBAL_CTOR_P (t)) 320 dump_string_field (di, "note", "global init"); 321 if (DECL_GLOBAL_DTOR_P (t)) 322 dump_string_field (di, "note", "global fini"); 323 if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)) 324 dump_string_field (di, "note", "pseudo tmpl"); 325 } 326 else 327 { 328 tree virt = THUNK_VIRTUAL_OFFSET (t); 329 330 dump_string_field (di, "note", "thunk"); 331 if (DECL_THIS_THUNK_P (t)) 332 dump_string_field (di, "note", "this adjusting"); 333 else 334 { 335 dump_string_field (di, "note", "result adjusting"); 336 if (virt) 337 virt = BINFO_VPTR_FIELD (virt); 338 } 339 dump_int (di, "fixd", THUNK_FIXED_OFFSET (t)); 340 if (virt) 341 dump_int (di, "virt", tree_low_cst (virt, 0)); 342 dump_child ("fn", DECL_INITIAL (t)); 343 } 344 break; 345 346 case NAMESPACE_DECL: 347 if (DECL_NAMESPACE_ALIAS (t)) 348 dump_child ("alis", DECL_NAMESPACE_ALIAS (t)); 349 else if (!dump_flag (di, TDF_SLIM, t)) 350 dump_child ("dcls", cp_namespace_decls (t)); 351 break; 352 353 case TEMPLATE_DECL: 354 dump_child ("rslt", DECL_TEMPLATE_RESULT (t)); 355 dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t)); 356 dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); 357 dump_child ("prms", DECL_TEMPLATE_PARMS (t)); 358 break; 359 360 case OVERLOAD: 361 dump_child ("crnt", OVL_CURRENT (t)); 362 dump_child ("chan", OVL_CHAIN (t)); 363 break; 364 365 case TRY_BLOCK: 366 dump_stmt (di, t); 367 if (CLEANUP_P (t)) 368 dump_string_field (di, "note", "cleanup"); 369 dump_child ("body", TRY_STMTS (t)); 370 dump_child ("hdlr", TRY_HANDLERS (t)); 371 break; 372 373 case EH_SPEC_BLOCK: 374 dump_stmt (di, t); 375 dump_child ("body", EH_SPEC_STMTS (t)); 376 dump_child ("raises", EH_SPEC_RAISES (t)); 377 break; 378 379 case PTRMEM_CST: 380 dump_child ("clas", PTRMEM_CST_CLASS (t)); 381 dump_child ("mbr", PTRMEM_CST_MEMBER (t)); 382 break; 383 384 case THROW_EXPR: 385 /* These nodes are unary, but do not have code class `1'. */ 386 dump_child ("op 0", TREE_OPERAND (t, 0)); 387 break; 388 389 case AGGR_INIT_EXPR: 390 { 391 int i = 0; 392 tree arg; 393 aggr_init_expr_arg_iterator iter; 394 dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t)); 395 dump_child ("fn", AGGR_INIT_EXPR_FN (t)); 396 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t) 397 { 398 char buffer[32]; 399 sprintf (buffer, "%u", i); 400 dump_child (buffer, arg); 401 i++; 402 } 403 dump_child ("decl", AGGR_INIT_EXPR_SLOT (t)); 404 } 405 break; 406 407 case HANDLER: 408 dump_stmt (di, t); 409 dump_child ("parm", HANDLER_PARMS (t)); 410 dump_child ("body", HANDLER_BODY (t)); 411 break; 412 413 case MUST_NOT_THROW_EXPR: 414 dump_stmt (di, t); 415 dump_child ("body", TREE_OPERAND (t, 0)); 416 dump_child ("cond", MUST_NOT_THROW_COND (t)); 417 break; 418 419 case USING_STMT: 420 dump_stmt (di, t); 421 dump_child ("nmsp", USING_STMT_NAMESPACE (t)); 422 break; 423 424 case CLEANUP_STMT: 425 dump_stmt (di, t); 426 dump_child ("decl", CLEANUP_DECL (t)); 427 dump_child ("expr", CLEANUP_EXPR (t)); 428 dump_child ("body", CLEANUP_BODY (t)); 429 break; 430 431 case IF_STMT: 432 dump_stmt (di, t); 433 dump_child ("cond", IF_COND (t)); 434 dump_child ("then", THEN_CLAUSE (t)); 435 dump_child ("else", ELSE_CLAUSE (t)); 436 break; 437 438 case BREAK_STMT: 439 case CONTINUE_STMT: 440 dump_stmt (di, t); 441 break; 442 443 case DO_STMT: 444 dump_stmt (di, t); 445 dump_child ("body", DO_BODY (t)); 446 dump_child ("cond", DO_COND (t)); 447 break; 448 449 case FOR_STMT: 450 dump_stmt (di, t); 451 dump_child ("init", FOR_INIT_STMT (t)); 452 dump_child ("cond", FOR_COND (t)); 453 dump_child ("expr", FOR_EXPR (t)); 454 dump_child ("body", FOR_BODY (t)); 455 break; 456 457 case RANGE_FOR_STMT: 458 dump_stmt (di, t); 459 dump_child ("decl", RANGE_FOR_DECL (t)); 460 dump_child ("expr", RANGE_FOR_EXPR (t)); 461 dump_child ("body", RANGE_FOR_BODY (t)); 462 break; 463 464 case SWITCH_STMT: 465 dump_stmt (di, t); 466 dump_child ("cond", SWITCH_STMT_COND (t)); 467 dump_child ("body", SWITCH_STMT_BODY (t)); 468 break; 469 470 case WHILE_STMT: 471 dump_stmt (di, t); 472 dump_child ("cond", WHILE_COND (t)); 473 dump_child ("body", WHILE_BODY (t)); 474 break; 475 476 case STMT_EXPR: 477 dump_child ("stmt", STMT_EXPR_STMT (t)); 478 break; 479 480 case EXPR_STMT: 481 dump_stmt (di, t); 482 dump_child ("expr", EXPR_STMT_EXPR (t)); 483 break; 484 485 default: 486 break; 487 } 488 489 return c_dump_tree (di, t); 490 } 491