1 /* Tree-dumping functionality for intermediate representation. 2 Copyright (C) 1999-2018 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 "cp-tree.h" 25 #include "tree-dump.h" 26 27 /* Dump a representation of the accessibility information associated 28 with T. */ 29 30 static void 31 dump_access (dump_info_p di, tree t) 32 { 33 if (TREE_PROTECTED(t)) 34 dump_string_field (di, "accs", "prot"); 35 else if (TREE_PRIVATE(t)) 36 dump_string_field (di, "accs", "priv"); 37 else 38 dump_string_field (di, "accs", "pub"); 39 } 40 41 /* Dump information common to statements from STMT. */ 42 43 static void 44 dump_stmt (dump_info_p di, const_tree t) 45 { 46 if (EXPR_HAS_LOCATION (t)) 47 dump_int (di, "line", EXPR_LINENO (t)); 48 } 49 50 bool 51 cp_dump_tree (void* dump_info, tree t) 52 { 53 enum tree_code code; 54 dump_info_p di = (dump_info_p) dump_info; 55 56 /* Figure out what kind of node this is. */ 57 code = TREE_CODE (t); 58 59 if (DECL_P (t)) 60 { 61 if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus) 62 dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t))); 63 } 64 65 switch (code) 66 { 67 case IDENTIFIER_NODE: 68 if (IDENTIFIER_ANY_OP_P (t)) 69 { 70 dump_string_field (di, "note", "operator"); 71 return true; 72 } 73 else if (IDENTIFIER_CONV_OP_P (t)) 74 { 75 dump_child ("tynm", TREE_TYPE (t)); 76 return true; 77 } 78 break; 79 80 case OFFSET_TYPE: 81 dump_string_field (di, "note", "ptrmem"); 82 dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); 83 dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); 84 return true; 85 86 case RECORD_TYPE: 87 if (TYPE_PTRMEMFUNC_P (t)) 88 { 89 dump_string_field (di, "note", "ptrmem"); 90 dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); 91 dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); 92 return true; 93 } 94 /* Fall through. */ 95 96 case UNION_TYPE: 97 /* Is it a type used as a base? */ 98 if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t) 99 && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t) 100 { 101 dump_child ("bfld", TYPE_CONTEXT (t)); 102 return true; 103 } 104 105 if (! MAYBE_CLASS_TYPE_P (t)) 106 break; 107 108 dump_child ("vfld", TYPE_VFIELD (t)); 109 if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t)) 110 dump_string(di, "spec"); 111 112 if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t)) 113 { 114 int i; 115 tree binfo; 116 tree base_binfo; 117 118 for (binfo = TYPE_BINFO (t), i = 0; 119 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 120 { 121 dump_child ("base", BINFO_TYPE (base_binfo)); 122 if (BINFO_VIRTUAL_P (base_binfo)) 123 dump_string_field (di, "spec", "virt"); 124 dump_access (di, base_binfo); 125 } 126 } 127 break; 128 129 case FIELD_DECL: 130 dump_access (di, t); 131 if (DECL_MUTABLE_P (t)) 132 dump_string_field (di, "spec", "mutable"); 133 break; 134 135 case VAR_DECL: 136 if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE) 137 dump_access (di, t); 138 if (TREE_STATIC (t) && !TREE_PUBLIC (t)) 139 dump_string_field (di, "link", "static"); 140 break; 141 142 case FUNCTION_DECL: 143 if (!DECL_THUNK_P (t)) 144 { 145 if (DECL_OVERLOADED_OPERATOR_P (t)) 146 dump_string_field (di, "note", "operator"); 147 if (DECL_FUNCTION_MEMBER_P (t)) 148 { 149 dump_string_field (di, "note", "member"); 150 dump_access (di, t); 151 } 152 if (DECL_PURE_VIRTUAL_P (t)) 153 dump_string_field (di, "spec", "pure"); 154 if (DECL_VIRTUAL_P (t)) 155 dump_string_field (di, "spec", "virt"); 156 if (DECL_CONSTRUCTOR_P (t)) 157 dump_string_field (di, "note", "constructor"); 158 if (DECL_DESTRUCTOR_P (t)) 159 dump_string_field (di, "note", "destructor"); 160 if (DECL_CONV_FN_P (t)) 161 dump_string_field (di, "note", "conversion"); 162 if (DECL_GLOBAL_CTOR_P (t)) 163 dump_string_field (di, "note", "global init"); 164 if (DECL_GLOBAL_DTOR_P (t)) 165 dump_string_field (di, "note", "global fini"); 166 if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)) 167 dump_string_field (di, "note", "pseudo tmpl"); 168 } 169 else 170 { 171 tree virt = THUNK_VIRTUAL_OFFSET (t); 172 173 dump_string_field (di, "note", "thunk"); 174 if (DECL_THIS_THUNK_P (t)) 175 dump_string_field (di, "note", "this adjusting"); 176 else 177 { 178 dump_string_field (di, "note", "result adjusting"); 179 if (virt) 180 virt = BINFO_VPTR_FIELD (virt); 181 } 182 dump_int (di, "fixd", THUNK_FIXED_OFFSET (t)); 183 if (virt) 184 dump_int (di, "virt", tree_to_shwi (virt)); 185 dump_child ("fn", DECL_INITIAL (t)); 186 } 187 break; 188 189 case NAMESPACE_DECL: 190 if (DECL_NAMESPACE_ALIAS (t)) 191 dump_child ("alis", DECL_NAMESPACE_ALIAS (t)); 192 else if (!dump_flag (di, TDF_SLIM, t)) 193 dump_child ("dcls", cp_namespace_decls (t)); 194 break; 195 196 case TEMPLATE_DECL: 197 dump_child ("rslt", DECL_TEMPLATE_RESULT (t)); 198 dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t)); 199 dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); 200 dump_child ("prms", DECL_TEMPLATE_PARMS (t)); 201 break; 202 203 case OVERLOAD: 204 dump_child ("name", OVL_NAME (t)); 205 if (!dump_flag (di, TDF_SLIM, t)) 206 for (lkp_iterator iter (t); iter; ++iter) 207 dump_child ("chld", *iter); 208 break; 209 210 case TRY_BLOCK: 211 dump_stmt (di, t); 212 if (CLEANUP_P (t)) 213 dump_string_field (di, "note", "cleanup"); 214 dump_child ("body", TRY_STMTS (t)); 215 dump_child ("hdlr", TRY_HANDLERS (t)); 216 break; 217 218 case EH_SPEC_BLOCK: 219 dump_stmt (di, t); 220 dump_child ("body", EH_SPEC_STMTS (t)); 221 dump_child ("raises", EH_SPEC_RAISES (t)); 222 break; 223 224 case PTRMEM_CST: 225 dump_child ("clas", PTRMEM_CST_CLASS (t)); 226 dump_child ("mbr", PTRMEM_CST_MEMBER (t)); 227 break; 228 229 case THROW_EXPR: 230 /* These nodes are unary, but do not have code class `1'. */ 231 dump_child ("op 0", TREE_OPERAND (t, 0)); 232 break; 233 234 case AGGR_INIT_EXPR: 235 { 236 int i = 0; 237 tree arg; 238 aggr_init_expr_arg_iterator iter; 239 dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t)); 240 dump_child ("fn", AGGR_INIT_EXPR_FN (t)); 241 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t) 242 { 243 char buffer[32]; 244 sprintf (buffer, "%u", i); 245 dump_child (buffer, arg); 246 i++; 247 } 248 dump_child ("decl", AGGR_INIT_EXPR_SLOT (t)); 249 } 250 break; 251 252 case HANDLER: 253 dump_stmt (di, t); 254 dump_child ("parm", HANDLER_PARMS (t)); 255 dump_child ("body", HANDLER_BODY (t)); 256 break; 257 258 case MUST_NOT_THROW_EXPR: 259 dump_stmt (di, t); 260 dump_child ("body", TREE_OPERAND (t, 0)); 261 dump_child ("cond", MUST_NOT_THROW_COND (t)); 262 break; 263 264 case USING_STMT: 265 dump_stmt (di, t); 266 dump_child ("nmsp", USING_STMT_NAMESPACE (t)); 267 break; 268 269 case CLEANUP_STMT: 270 dump_stmt (di, t); 271 dump_child ("decl", CLEANUP_DECL (t)); 272 dump_child ("expr", CLEANUP_EXPR (t)); 273 dump_child ("body", CLEANUP_BODY (t)); 274 break; 275 276 case IF_STMT: 277 dump_stmt (di, t); 278 dump_child ("cond", IF_COND (t)); 279 dump_child ("then", THEN_CLAUSE (t)); 280 dump_child ("else", ELSE_CLAUSE (t)); 281 break; 282 283 case BREAK_STMT: 284 case CONTINUE_STMT: 285 dump_stmt (di, t); 286 break; 287 288 case DO_STMT: 289 dump_stmt (di, t); 290 dump_child ("body", DO_BODY (t)); 291 dump_child ("cond", DO_COND (t)); 292 break; 293 294 case FOR_STMT: 295 dump_stmt (di, t); 296 dump_child ("init", FOR_INIT_STMT (t)); 297 dump_child ("cond", FOR_COND (t)); 298 dump_child ("expr", FOR_EXPR (t)); 299 dump_child ("body", FOR_BODY (t)); 300 break; 301 302 case RANGE_FOR_STMT: 303 dump_stmt (di, t); 304 dump_child ("decl", RANGE_FOR_DECL (t)); 305 dump_child ("expr", RANGE_FOR_EXPR (t)); 306 dump_child ("body", RANGE_FOR_BODY (t)); 307 break; 308 309 case SWITCH_STMT: 310 dump_stmt (di, t); 311 dump_child ("cond", SWITCH_STMT_COND (t)); 312 dump_child ("body", SWITCH_STMT_BODY (t)); 313 break; 314 315 case WHILE_STMT: 316 dump_stmt (di, t); 317 dump_child ("cond", WHILE_COND (t)); 318 dump_child ("body", WHILE_BODY (t)); 319 break; 320 321 case STMT_EXPR: 322 dump_child ("stmt", STMT_EXPR_STMT (t)); 323 break; 324 325 case EXPR_STMT: 326 dump_stmt (di, t); 327 dump_child ("expr", EXPR_STMT_EXPR (t)); 328 break; 329 330 default: 331 break; 332 } 333 334 return c_dump_tree (di, t); 335 } 336