1 /* Prints out trees in human readable form. 2 Copyright (C) 1992-2018 Free Software Foundation, Inc. 3 Hacked by Michael Tiemann (tiemann@cygnus.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 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "cp-tree.h" 26 #include "print-tree.h" 27 28 void 29 cxx_print_decl (FILE *file, tree node, int indent) 30 { 31 if (TREE_CODE (node) == FIELD_DECL) 32 { 33 if (DECL_MUTABLE_P (node)) 34 { 35 indent_to (file, indent + 3); 36 fprintf (file, " mutable "); 37 } 38 return; 39 } 40 41 if (!CODE_CONTAINS_STRUCT (TREE_CODE (node), TS_DECL_COMMON) 42 || !DECL_LANG_SPECIFIC (node)) 43 return; 44 if (TREE_CODE (node) == FUNCTION_DECL) 45 { 46 int flags = TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE 47 |TFF_FUNCTION_DEFAULT_ARGUMENTS|TFF_EXCEPTION_SPECIFICATION ; 48 indent_to (file, indent + 3); 49 fprintf (file, " full-name \"%s\"", decl_as_string (node, flags)); 50 } 51 else if (TREE_CODE (node) == TEMPLATE_DECL) 52 { 53 print_node (file, "parms", DECL_TEMPLATE_PARMS (node), indent + 4); 54 indent_to (file, indent + 3); 55 fprintf (file, " full-name \"%s\"", 56 decl_as_string (node, TFF_TEMPLATE_HEADER)); 57 } 58 59 indent_to (file, indent + 3); 60 if (DECL_EXTERNAL (node) && DECL_NOT_REALLY_EXTERN (node)) 61 fprintf (file, " not-really-extern"); 62 if (TREE_CODE (node) == FUNCTION_DECL 63 && DECL_PENDING_INLINE_INFO (node)) 64 fprintf (file, " pending-inline-info %p", 65 (void *) DECL_PENDING_INLINE_INFO (node)); 66 if (VAR_OR_FUNCTION_DECL_P (node) 67 && DECL_TEMPLATE_INFO (node)) 68 fprintf (file, " template-info %p", 69 (void *) DECL_TEMPLATE_INFO (node)); 70 } 71 72 void 73 cxx_print_type (FILE *file, tree node, int indent) 74 { 75 switch (TREE_CODE (node)) 76 { 77 case BOUND_TEMPLATE_TEMPLATE_PARM: 78 print_node (file, "args", TYPE_TI_ARGS (node), indent + 4); 79 gcc_fallthrough (); 80 81 case TEMPLATE_TYPE_PARM: 82 case TEMPLATE_TEMPLATE_PARM: 83 indent_to (file, indent + 3); 84 fprintf (file, "index %d level %d orig_level %d", 85 TEMPLATE_TYPE_IDX (node), TEMPLATE_TYPE_LEVEL (node), 86 TEMPLATE_TYPE_ORIG_LEVEL (node)); 87 return; 88 89 case FUNCTION_TYPE: 90 case METHOD_TYPE: 91 if (TYPE_RAISES_EXCEPTIONS (node)) 92 print_node (file, "throws", TYPE_RAISES_EXCEPTIONS (node), indent + 4); 93 return; 94 95 case RECORD_TYPE: 96 case UNION_TYPE: 97 break; 98 99 case DECLTYPE_TYPE: 100 print_node (file, "expr", DECLTYPE_TYPE_EXPR (node), indent + 4); 101 return; 102 103 case TYPENAME_TYPE: 104 print_node (file, "fullname", TYPENAME_TYPE_FULLNAME (node), 105 indent + 4); 106 return; 107 108 case TYPE_PACK_EXPANSION: 109 print_node (file, "args", PACK_EXPANSION_EXTRA_ARGS (node), indent + 4); 110 return; 111 112 default: 113 return; 114 } 115 116 if (TYPE_PTRMEMFUNC_P (node)) 117 print_node (file, "ptrmemfunc fn type", TYPE_PTRMEMFUNC_FN_TYPE (node), 118 indent + 4); 119 120 if (! CLASS_TYPE_P (node)) 121 return; 122 123 indent_to (file, indent + 4); 124 fprintf (file, "full-name \"%s\"", 125 type_as_string (node, TFF_CLASS_KEY_OR_ENUM)); 126 127 indent_to (file, indent + 3); 128 129 if (TYPE_NEEDS_CONSTRUCTING (node)) 130 fputs ( " needs-constructor", file); 131 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (node)) 132 fputs (" needs-destructor", file); 133 if (TYPE_HAS_DEFAULT_CONSTRUCTOR (node)) 134 fputs (" X()", file); 135 if (TYPE_HAS_CONVERSION (node)) 136 fputs (" has-type-conversion", file); 137 if (TYPE_HAS_COPY_CTOR (node)) 138 { 139 if (TYPE_HAS_CONST_COPY_CTOR (node)) 140 fputs (" X(constX&)", file); 141 else 142 fputs (" X(X&)", file); 143 } 144 if (TYPE_HAS_NEW_OPERATOR (node)) 145 fputs (" new", file); 146 if (TYPE_HAS_ARRAY_NEW_OPERATOR (node)) 147 fputs (" new[]", file); 148 if (TYPE_GETS_DELETE (node) & 1) 149 fputs (" delete", file); 150 if (TYPE_GETS_DELETE (node) & 2) 151 fputs (" delete[]", file); 152 if (TYPE_HAS_COPY_ASSIGN (node)) 153 fputs (" this=(X&)", file); 154 155 if (TREE_CODE (node) == RECORD_TYPE) 156 { 157 if (TYPE_BINFO (node)) 158 fprintf (file, " n_parents=%d", 159 BINFO_N_BASE_BINFOS (TYPE_BINFO (node))); 160 else 161 fprintf (file, " no-binfo"); 162 163 fprintf (file, " use_template=%d", CLASSTYPE_USE_TEMPLATE (node)); 164 if (CLASSTYPE_INTERFACE_ONLY (node)) 165 fprintf (file, " interface-only"); 166 if (CLASSTYPE_INTERFACE_UNKNOWN (node)) 167 fprintf (file, " interface-unknown"); 168 } 169 } 170 171 void 172 cxx_print_identifier (FILE *file, tree node, int indent) 173 { 174 if (indent == 0) 175 fprintf (file, " "); 176 else 177 indent_to (file, indent + 4); 178 fprintf (file, "%s local bindings <%p>", get_identifier_kind_name (node), 179 (void *) IDENTIFIER_BINDING (node)); 180 } 181 182 void 183 cxx_print_lambda_node (FILE *file, tree node, int indent) 184 { 185 if (LAMBDA_EXPR_MUTABLE_P (node)) 186 fprintf (file, " /mutable"); 187 fprintf (file, " default_capture_mode=["); 188 switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (node)) 189 { 190 case CPLD_NONE: 191 fprintf (file, "NONE"); 192 break; 193 case CPLD_COPY: 194 fprintf (file, "COPY"); 195 break; 196 case CPLD_REFERENCE: 197 fprintf (file, "CPLD_REFERENCE"); 198 break; 199 default: 200 fprintf (file, "??"); 201 break; 202 } 203 fprintf (file, "] "); 204 print_node (file, "capture_list", LAMBDA_EXPR_CAPTURE_LIST (node), indent + 4); 205 print_node (file, "this_capture", LAMBDA_EXPR_THIS_CAPTURE (node), indent + 4); 206 } 207 208 void 209 cxx_print_xnode (FILE *file, tree node, int indent) 210 { 211 switch (TREE_CODE (node)) 212 { 213 case BASELINK: 214 print_node (file, "functions", BASELINK_FUNCTIONS (node), indent + 4); 215 print_node (file, "binfo", BASELINK_BINFO (node), indent + 4); 216 print_node (file, "access_binfo", BASELINK_ACCESS_BINFO (node), 217 indent + 4); 218 print_node (file, "optype", BASELINK_OPTYPE (node), indent + 4); 219 break; 220 case OVERLOAD: 221 print_node (file, "function", OVL_FUNCTION (node), indent+4); 222 print_node (file, "next", OVL_CHAIN (node), indent+4); 223 break; 224 case TEMPLATE_PARM_INDEX: 225 print_node (file, "decl", TEMPLATE_PARM_DECL (node), indent+4); 226 indent_to (file, indent + 3); 227 fprintf (file, "index %d level %d orig_level %d", 228 TEMPLATE_PARM_IDX (node), TEMPLATE_PARM_LEVEL (node), 229 TEMPLATE_PARM_ORIG_LEVEL (node)); 230 break; 231 case TEMPLATE_INFO: 232 print_node (file, "template", TI_TEMPLATE (node), indent+4); 233 print_node (file, "args", TI_ARGS (node), indent+4); 234 if (TI_PENDING_TEMPLATE_FLAG (node)) 235 { 236 indent_to (file, indent + 3); 237 fprintf (file, "pending_template"); 238 } 239 break; 240 case CONSTRAINT_INFO: 241 { 242 tree_constraint_info *cinfo = (tree_constraint_info *)node; 243 if (cinfo->template_reqs) 244 print_node (file, "template_reqs", cinfo->template_reqs, indent+4); 245 if (cinfo->declarator_reqs) 246 print_node (file, "declarator_reqs", cinfo->declarator_reqs, 247 indent+4); 248 print_node (file, "associated_constr", 249 cinfo->associated_constr, indent+4); 250 break; 251 } 252 case ARGUMENT_PACK_SELECT: 253 print_node (file, "pack", ARGUMENT_PACK_SELECT_FROM_PACK (node), 254 indent+4); 255 indent_to (file, indent + 3); 256 fprintf (file, "index %d", ARGUMENT_PACK_SELECT_INDEX (node)); 257 break; 258 case DEFERRED_NOEXCEPT: 259 print_node (file, "pattern", DEFERRED_NOEXCEPT_PATTERN (node), indent+4); 260 print_node (file, "args", DEFERRED_NOEXCEPT_ARGS (node), indent+4); 261 break; 262 case TRAIT_EXPR: 263 indent_to (file, indent+4); 264 fprintf (file, "kind %d", TRAIT_EXPR_KIND (node)); 265 print_node (file, "type 1", TRAIT_EXPR_TYPE1 (node), indent+4); 266 if (TRAIT_EXPR_TYPE2 (node)) 267 print_node (file, "type 2", TRAIT_EXPR_TYPE2 (node), indent+4); 268 break; 269 case LAMBDA_EXPR: 270 cxx_print_lambda_node (file, node, indent); 271 break; 272 default: 273 break; 274 } 275 } 276 277 /* Print the node NODE on standard error, for debugging. */ 278 279 DEBUG_FUNCTION void 280 debug_tree (cp_expr node) 281 { 282 debug_tree (node.get_value()); 283 } 284