Branch data Line data Source code
1 : : /* Prints out trees in human readable form.
2 : : Copyright (C) 1992-2024 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 : 0 : cxx_print_decl (FILE *file, tree node, int indent)
30 : : {
31 : 0 : if (TREE_CODE (node) == FIELD_DECL)
32 : : {
33 : 0 : if (DECL_MUTABLE_P (node))
34 : : {
35 : 0 : indent_to (file, indent + 3);
36 : 0 : fprintf (file, " mutable ");
37 : : }
38 : 0 : return;
39 : : }
40 : :
41 : 0 : if (TREE_CODE (node) == FUNCTION_DECL)
42 : : {
43 : 0 : int flags = TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
44 : : |TFF_FUNCTION_DEFAULT_ARGUMENTS|TFF_EXCEPTION_SPECIFICATION ;
45 : 0 : indent_to (file, indent + 3);
46 : 0 : fprintf (file, " full-name \"%s\"", decl_as_string (node, flags));
47 : : }
48 : 0 : else if (TREE_CODE (node) == TEMPLATE_DECL)
49 : : {
50 : 0 : print_node (file, "result", DECL_TEMPLATE_RESULT (node), indent + 4);
51 : 0 : print_node (file, "parms", DECL_TEMPLATE_PARMS (node), indent + 4);
52 : 0 : indent_to (file, indent + 3);
53 : 0 : fprintf (file, " full-name \"%s\"",
54 : : decl_as_string (node, TFF_TEMPLATE_HEADER));
55 : : }
56 : :
57 : 0 : bool need_indent = true;
58 : :
59 : 0 : tree ntnode = STRIP_TEMPLATE (node);
60 : 0 : if (TREE_CODE (ntnode) == FUNCTION_DECL
61 : : || TREE_CODE (ntnode) == VAR_DECL
62 : : || TREE_CODE (ntnode) == TYPE_DECL
63 : : || TREE_CODE (ntnode) == CONCEPT_DECL
64 : : || TREE_CODE (ntnode) == NAMESPACE_DECL)
65 : : {
66 : 0 : unsigned m = 0;
67 : 0 : if (DECL_LANG_SPECIFIC (ntnode) && DECL_MODULE_IMPORT_P (ntnode))
68 : 0 : m = get_importing_module (ntnode, true);
69 : :
70 : 0 : if (const char *name = m == ~0u ? "" : module_name (m, true))
71 : : {
72 : 0 : if (need_indent)
73 : 0 : indent_to (file, indent + 3);
74 : 0 : fprintf (file, " module %d:%s", m, name);
75 : 0 : need_indent = false;
76 : : }
77 : :
78 : 0 : if (DECL_LANG_SPECIFIC (ntnode))
79 : : {
80 : 0 : if (DECL_MODULE_PURVIEW_P (ntnode))
81 : : {
82 : 0 : if (need_indent)
83 : 0 : indent_to (file, indent + 3);
84 : 0 : fprintf (file, " purview");
85 : 0 : need_indent = false;
86 : : }
87 : 0 : if (DECL_MODULE_ATTACH_P (ntnode))
88 : : {
89 : 0 : if (need_indent)
90 : 0 : indent_to (file, indent + 3);
91 : 0 : fprintf (file, " attached");
92 : 0 : need_indent = false;
93 : : }
94 : : }
95 : : }
96 : :
97 : 0 : if (DECL_MODULE_EXPORT_P (node))
98 : : {
99 : 0 : if (need_indent)
100 : 0 : indent_to (file, indent + 3);
101 : 0 : fprintf (file, " exported");
102 : 0 : need_indent = false;
103 : : }
104 : :
105 : 0 : if (!CODE_CONTAINS_STRUCT (TREE_CODE (node), TS_DECL_COMMON)
106 : 0 : || !DECL_LANG_SPECIFIC (node))
107 : : return;
108 : :
109 : 0 : if (DECL_EXTERNAL (node) && DECL_NOT_REALLY_EXTERN (node))
110 : : {
111 : 0 : if (need_indent)
112 : 0 : indent_to (file, indent + 3);
113 : 0 : fprintf (file, " not-really-extern");
114 : 0 : need_indent = false;
115 : : }
116 : :
117 : 0 : if (TREE_CODE (node) == FUNCTION_DECL
118 : 0 : && DECL_PENDING_INLINE_INFO (node))
119 : : {
120 : 0 : if (need_indent)
121 : 0 : indent_to (file, indent + 3);
122 : 0 : fprintf (file, " pending-inline-info %p",
123 : 0 : (void *) DECL_PENDING_INLINE_INFO (node));
124 : 0 : need_indent = false;
125 : : }
126 : :
127 : 0 : if ((VAR_OR_FUNCTION_DECL_P (node)
128 : : || TREE_CODE (node) == FIELD_DECL
129 : : || TREE_CODE (node) == TYPE_DECL
130 : : || TREE_CODE (node) == CONCEPT_DECL
131 : : || TREE_CODE (node) == TEMPLATE_DECL)
132 : 0 : && DECL_TEMPLATE_INFO (node))
133 : : {
134 : 0 : print_node (file, "template-info", DECL_TEMPLATE_INFO (node),
135 : : indent + 4);
136 : 0 : indent_to (file, indent + 3);
137 : 0 : fprintf (file, " use_template=%d", DECL_USE_TEMPLATE (node));
138 : : }
139 : : }
140 : :
141 : : void
142 : 0 : cxx_print_type (FILE *file, tree node, int indent)
143 : : {
144 : 0 : if (tree ti = TYPE_TEMPLATE_INFO (node))
145 : 0 : print_node (file, "template-info", ti, indent + 4);
146 : :
147 : 0 : switch (TREE_CODE (node))
148 : : {
149 : 0 : case BOUND_TEMPLATE_TEMPLATE_PARM:
150 : 0 : case TEMPLATE_TYPE_PARM:
151 : 0 : case TEMPLATE_TEMPLATE_PARM:
152 : 0 : print_node (file, "tpi", TEMPLATE_TYPE_PARM_INDEX (node), indent + 4);
153 : 0 : return;
154 : :
155 : 0 : case FUNCTION_TYPE:
156 : 0 : case METHOD_TYPE:
157 : 0 : if (TYPE_RAISES_EXCEPTIONS (node))
158 : 0 : print_node (file, "throws", TYPE_RAISES_EXCEPTIONS (node), indent + 4);
159 : : return;
160 : :
161 : 0 : case RECORD_TYPE:
162 : 0 : case UNION_TYPE:
163 : 0 : break;
164 : :
165 : 0 : case DECLTYPE_TYPE:
166 : 0 : print_node (file, "expr", DECLTYPE_TYPE_EXPR (node), indent + 4);
167 : 0 : return;
168 : :
169 : 0 : case DEPENDENT_OPERATOR_TYPE:
170 : 0 : print_node (file, "saved_lookups",
171 : 0 : DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (node),
172 : : indent + 4);
173 : 0 : return;
174 : :
175 : 0 : case TYPENAME_TYPE:
176 : 0 : print_node (file, "fullname", TYPENAME_TYPE_FULLNAME (node),
177 : : indent + 4);
178 : 0 : return;
179 : :
180 : 0 : case TYPEOF_TYPE:
181 : 0 : print_node (file, "expr", TYPEOF_TYPE_EXPR (node), indent + 4);
182 : 0 : return;
183 : :
184 : 0 : case BASES:
185 : 0 : if (BASES_DIRECT (node))
186 : 0 : fputs (" direct", file);
187 : 0 : print_node (file, "type", BASES_TYPE (node), indent + 4);
188 : 0 : return;
189 : :
190 : 0 : case TYPE_PACK_EXPANSION:
191 : 0 : print_node (file, "pattern", PACK_EXPANSION_PATTERN (node), indent + 4);
192 : 0 : print_node (file, "args", PACK_EXPANSION_EXTRA_ARGS (node), indent + 4);
193 : 0 : return;
194 : :
195 : : default:
196 : : return;
197 : : }
198 : :
199 : 0 : if (TYPE_PTRMEMFUNC_P (node))
200 : 0 : print_node (file, "ptrmemfunc fn type", TYPE_PTRMEMFUNC_FN_TYPE (node),
201 : : indent + 4);
202 : :
203 : 0 : if (! CLASS_TYPE_P (node))
204 : : return;
205 : :
206 : 0 : indent_to (file, indent + 4);
207 : 0 : fprintf (file, "full-name \"%s\"",
208 : : type_as_string (node, TFF_CLASS_KEY_OR_ENUM));
209 : :
210 : 0 : indent_to (file, indent + 3);
211 : :
212 : 0 : if (TYPE_NEEDS_CONSTRUCTING (node))
213 : 0 : fputs ( " needs-constructor", file);
214 : 0 : if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (node))
215 : 0 : fputs (" needs-destructor", file);
216 : 0 : if (TYPE_HAS_DEFAULT_CONSTRUCTOR (node))
217 : 0 : fputs (" X()", file);
218 : 0 : if (TYPE_HAS_CONVERSION (node))
219 : 0 : fputs (" has-type-conversion", file);
220 : 0 : if (TYPE_HAS_COPY_CTOR (node))
221 : : {
222 : 0 : if (TYPE_HAS_CONST_COPY_CTOR (node))
223 : 0 : fputs (" X(constX&)", file);
224 : : else
225 : 0 : fputs (" X(X&)", file);
226 : : }
227 : 0 : if (TYPE_HAS_NEW_OPERATOR (node))
228 : 0 : fputs (" new", file);
229 : 0 : if (TYPE_HAS_ARRAY_NEW_OPERATOR (node))
230 : 0 : fputs (" new[]", file);
231 : 0 : if (TYPE_GETS_DELETE (node) & 1)
232 : 0 : fputs (" delete", file);
233 : 0 : if (TYPE_GETS_DELETE (node) & 2)
234 : 0 : fputs (" delete[]", file);
235 : 0 : if (TYPE_HAS_COPY_ASSIGN (node))
236 : 0 : fputs (" this=(X&)", file);
237 : :
238 : 0 : if (TREE_CODE (node) == RECORD_TYPE)
239 : : {
240 : 0 : if (TYPE_BINFO (node))
241 : 0 : fprintf (file, " n_parents=%d",
242 : 0 : BINFO_N_BASE_BINFOS (TYPE_BINFO (node)));
243 : : else
244 : 0 : fprintf (file, " no-binfo");
245 : :
246 : 0 : fprintf (file, " use_template=%d", CLASSTYPE_USE_TEMPLATE (node));
247 : 0 : if (CLASSTYPE_INTERFACE_ONLY (node))
248 : 0 : fprintf (file, " interface-only");
249 : 0 : if (CLASSTYPE_INTERFACE_UNKNOWN (node))
250 : 0 : fprintf (file, " interface-unknown");
251 : : }
252 : : }
253 : :
254 : : void
255 : 0 : cxx_print_identifier (FILE *file, tree node, int indent)
256 : : {
257 : 0 : if (indent == 0)
258 : 0 : fprintf (file, " ");
259 : : else
260 : 0 : indent_to (file, indent + 4);
261 : 0 : fprintf (file, "%s local bindings <%p>", get_identifier_kind_name (node),
262 : 0 : (void *) IDENTIFIER_BINDING (node));
263 : 0 : }
264 : :
265 : : void
266 : 0 : cxx_print_lambda_node (FILE *file, tree node, int indent)
267 : : {
268 : 0 : fprintf (file, " default_capture_mode=[");
269 : 0 : switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (node))
270 : : {
271 : 0 : case CPLD_NONE:
272 : 0 : fprintf (file, "NONE");
273 : 0 : break;
274 : 0 : case CPLD_COPY:
275 : 0 : fprintf (file, "COPY");
276 : 0 : break;
277 : 0 : case CPLD_REFERENCE:
278 : 0 : fprintf (file, "CPLD_REFERENCE");
279 : 0 : break;
280 : 0 : default:
281 : 0 : fprintf (file, "??");
282 : 0 : break;
283 : : }
284 : 0 : fprintf (file, "] ");
285 : 0 : print_node (file, "capture_list", LAMBDA_EXPR_CAPTURE_LIST (node), indent + 4);
286 : 0 : print_node (file, "this_capture", LAMBDA_EXPR_THIS_CAPTURE (node), indent + 4);
287 : 0 : }
288 : :
289 : : void
290 : 0 : cxx_print_xnode (FILE *file, tree node, int indent)
291 : : {
292 : 0 : switch (TREE_CODE (node))
293 : : {
294 : 0 : case BASELINK:
295 : 0 : print_node (file, "functions", BASELINK_FUNCTIONS (node), indent + 4);
296 : 0 : print_node (file, "binfo", BASELINK_BINFO (node), indent + 4);
297 : 0 : print_node (file, "access_binfo", BASELINK_ACCESS_BINFO (node),
298 : : indent + 4);
299 : 0 : print_node (file, "optype", BASELINK_OPTYPE (node), indent + 4);
300 : 0 : break;
301 : 0 : case OVERLOAD:
302 : 0 : print_node (file, "function", OVL_FUNCTION (node), indent + 4);
303 : 0 : print_node (file, "next", OVL_CHAIN (node), indent + 4);
304 : 0 : break;
305 : 0 : case BINDING_VECTOR:
306 : 0 : {
307 : 0 : unsigned len = BINDING_VECTOR_NUM_CLUSTERS (node);
308 : 0 : print_node (file, "name", BINDING_VECTOR_NAME (node), indent + 4);
309 : 0 : fprintf (file, " clusters %u, alloc %u", len,
310 : 0 : BINDING_VECTOR_ALLOC_CLUSTERS (node));
311 : 0 : for (unsigned ix = 0; ix != len; ix++)
312 : : {
313 : 0 : binding_cluster *cluster = &BINDING_VECTOR_CLUSTER (node, ix);
314 : : char pfx[32];
315 : 0 : for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
316 : 0 : if (cluster->indices[jx].span)
317 : : {
318 : 0 : int len = sprintf (pfx, "module:%u",
319 : 0 : cluster->indices[jx].base);
320 : 0 : if (cluster->indices[jx].span > 1)
321 : 0 : len += sprintf (&pfx[len], "(+%u)",
322 : : cluster->indices[jx].span);
323 : 0 : len += sprintf (&pfx[len], " cluster:%u/%u", ix, jx);
324 : 0 : binding_slot &slot = cluster->slots[jx];
325 : 0 : if (slot.is_lazy ())
326 : : {
327 : 0 : indent_to (file, indent + 4);
328 : 0 : unsigned lazy = slot.get_lazy ();
329 : 0 : fprintf (file, "%s snum:%u", pfx, lazy);
330 : : }
331 : 0 : else if (slot)
332 : 0 : print_node (file, pfx, slot, indent + 4);
333 : : else
334 : : {
335 : 0 : indent_to (file, indent + 4);
336 : 0 : fprintf (file, "%s NULL", pfx);
337 : : }
338 : : }
339 : : }
340 : : }
341 : : break;
342 : 0 : case TEMPLATE_PARM_INDEX:
343 : 0 : print_node (file, "decl", TEMPLATE_PARM_DECL (node), indent+4);
344 : 0 : indent_to (file, indent + 3);
345 : 0 : fprintf (file, "index %d level %d orig_level %d",
346 : 0 : TEMPLATE_PARM_IDX (node), TEMPLATE_PARM_LEVEL (node),
347 : 0 : TEMPLATE_PARM_ORIG_LEVEL (node));
348 : 0 : break;
349 : 0 : case TEMPLATE_INFO:
350 : 0 : print_node (file, "template", TI_TEMPLATE (node), indent+4);
351 : 0 : print_node (file, "args", TI_ARGS (node), indent+4);
352 : 0 : if (TI_TEMPLATE (node)
353 : 0 : && PRIMARY_TEMPLATE_P (TI_TEMPLATE (node)))
354 : 0 : print_node (file, "partial", TI_PARTIAL_INFO (node), indent+4);
355 : 0 : if (TI_PENDING_TEMPLATE_FLAG (node))
356 : : {
357 : 0 : indent_to (file, indent + 3);
358 : 0 : fprintf (file, "pending_template");
359 : : }
360 : : break;
361 : 0 : case CONSTRAINT_INFO:
362 : 0 : {
363 : 0 : tree_constraint_info *cinfo = (tree_constraint_info *)node;
364 : 0 : if (cinfo->template_reqs)
365 : 0 : print_node (file, "template_reqs", cinfo->template_reqs, indent+4);
366 : 0 : if (cinfo->declarator_reqs)
367 : 0 : print_node (file, "declarator_reqs", cinfo->declarator_reqs,
368 : : indent+4);
369 : 0 : print_node (file, "associated_constr",
370 : : cinfo->associated_constr, indent+4);
371 : 0 : break;
372 : : }
373 : 0 : case ARGUMENT_PACK_SELECT:
374 : 0 : print_node (file, "pack", ARGUMENT_PACK_SELECT_FROM_PACK (node),
375 : : indent+4);
376 : 0 : indent_to (file, indent + 3);
377 : 0 : fprintf (file, "index %d", ARGUMENT_PACK_SELECT_INDEX (node));
378 : 0 : break;
379 : 0 : case DEFERRED_NOEXCEPT:
380 : 0 : print_node (file, "pattern", DEFERRED_NOEXCEPT_PATTERN (node), indent+4);
381 : 0 : print_node (file, "args", DEFERRED_NOEXCEPT_ARGS (node), indent+4);
382 : 0 : break;
383 : 0 : case TRAIT_EXPR:
384 : 0 : indent_to (file, indent+4);
385 : 0 : fprintf (file, "kind %d", TRAIT_EXPR_KIND (node));
386 : 0 : print_node (file, "type 1", TRAIT_EXPR_TYPE1 (node), indent+4);
387 : 0 : if (TRAIT_EXPR_TYPE2 (node))
388 : 0 : print_node (file, "type 2", TRAIT_EXPR_TYPE2 (node), indent+4);
389 : : break;
390 : 0 : case LAMBDA_EXPR:
391 : 0 : cxx_print_lambda_node (file, node, indent);
392 : 0 : break;
393 : 0 : case STATIC_ASSERT:
394 : 0 : if (location_t loc = STATIC_ASSERT_SOURCE_LOCATION (node))
395 : : {
396 : 0 : expanded_location xloc = expand_location (loc);
397 : 0 : indent_to (file, indent+4);
398 : 0 : fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column);
399 : : }
400 : 0 : print_node (file, "condition", STATIC_ASSERT_CONDITION (node), indent+4);
401 : 0 : if (tree message = STATIC_ASSERT_MESSAGE (node))
402 : 0 : print_node (file, "message", message, indent+4);
403 : : break;
404 : 0 : case PTRMEM_CST:
405 : 0 : print_node (file, "member", PTRMEM_CST_MEMBER (node), indent+4);
406 : 0 : break;
407 : : default:
408 : : break;
409 : : }
410 : 0 : }
411 : :
412 : : /* Print the node NODE on standard error, for debugging. */
413 : :
414 : : DEBUG_FUNCTION void
415 : 0 : debug_tree (cp_expr node)
416 : : {
417 : 0 : debug_tree (node.get_value());
418 : 0 : }
419 : :
420 : : DEBUG_FUNCTION void
421 : 0 : debug_overload (tree node)
422 : : {
423 : 0 : FILE *file = stdout;
424 : :
425 : 0 : for (lkp_iterator iter (node); iter; ++iter)
426 : : {
427 : 0 : tree decl = *iter;
428 : 0 : auto xloc = expand_location (DECL_SOURCE_LOCATION (decl));
429 : 0 : auto fullname = decl_as_string (decl, 0);
430 : 0 : bool using_p = iter.using_p ();
431 : 0 : bool hidden_p = iter.hidden_p ();
432 : :
433 : 0 : fprintf (file, "%p:%c%c %s:%d:%d \"%s\"\n", (void *)decl,
434 : : hidden_p ? 'H' : '-',
435 : : using_p ? 'U' : '-',
436 : : xloc.file, xloc.line, xloc.column, fullname);
437 : : }
438 : 0 : }
|
