typeck.c (cp_truthvalue_conversion): Add tsubst_flags_t parameter and use it in calls...
[official-gcc.git] / gcc / print-tree.c
blobbd09ec4d7a7afcfdef0e5278e3cd232febb5266a
1 /* Prints out tree in human readable form - GCC
2 Copyright (C) 1990-2019 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "cgraph.h"
27 #include "diagnostic.h"
28 #include "varasm.h"
29 #include "print-rtl.h"
30 #include "stor-layout.h"
31 #include "langhooks.h"
32 #include "tree-iterator.h"
33 #include "gimple-pretty-print.h" /* FIXME */
34 #include "tree-cfg.h"
35 #include "dumpfile.h"
36 #include "print-tree.h"
38 /* Define the hash table of nodes already seen.
39 Such nodes are not repeated; brief cross-references are used. */
41 #define HASH_SIZE 37
43 static hash_set<tree> *table = NULL;
45 /* Print PREFIX and ADDR to FILE. */
46 void
47 dump_addr (FILE *file, const char *prefix, const void *addr)
49 if (flag_dump_noaddr || flag_dump_unnumbered)
50 fprintf (file, "%s#", prefix);
51 else
52 fprintf (file, "%s" HOST_PTR_PRINTF, prefix, addr);
55 /* Print to FILE a NODE representing a REAL_CST constant, including
56 Infinity and NaN. Be verbose when BFRIEF is false. */
58 static void
59 print_real_cst (FILE *file, const_tree node, bool brief)
61 if (TREE_OVERFLOW (node))
62 fprintf (file, " overflow");
64 REAL_VALUE_TYPE d = TREE_REAL_CST (node);
65 if (REAL_VALUE_ISINF (d))
66 fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
67 else if (REAL_VALUE_ISNAN (d))
69 /* Print a NaN in the format [-][Q]NaN[(significand[exponent])]
70 where significand is a hexadecimal string that starts with
71 the 0x prefix followed by 0 if the number is not canonical
72 and a non-zero digit if it is, and exponent is decimal. */
73 unsigned start = 0;
74 const char *psig = (const char *) d.sig;
75 for (unsigned i = 0; i != sizeof d.sig; ++i)
76 if (psig[i])
78 start = i;
79 break;
82 fprintf (file, " %s%sNaN", d.sign ? "-" : "",
83 d.signalling ? "S" : "Q");
85 if (brief)
86 return;
88 if (start)
89 fprintf (file, "(0x%s", d.canonical ? "" : "0");
90 else if (d.uexp)
91 fprintf (file, "(%s", d.canonical ? "" : "0");
92 else if (!d.canonical)
94 fprintf (file, "(0)");
95 return;
98 if (psig[start])
100 for (unsigned i = start; i != sizeof d.sig; ++i)
101 if (i == start)
102 fprintf (file, "%x", psig[i]);
103 else
104 fprintf (file, "%02x", psig[i]);
107 if (d.uexp)
108 fprintf (file, "%se%u)", psig[start] ? "," : "", d.uexp);
109 else if (psig[start])
110 fputc (')', file);
112 else
114 char string[64];
115 real_to_decimal (string, &d, sizeof (string), 0, 1);
116 fprintf (file, " %s", string);
120 /* Print a node in brief fashion, with just the code, address and name. */
122 void
123 print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
125 enum tree_code_class tclass;
127 if (node == 0)
128 return;
130 tclass = TREE_CODE_CLASS (TREE_CODE (node));
132 /* Always print the slot this node is in, and its code, address and
133 name if any. */
134 if (indent > 0)
135 fprintf (file, " ");
136 fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node)));
137 dump_addr (file, " ", node);
139 if (tclass == tcc_declaration)
141 if (DECL_NAME (node))
142 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
143 else if (TREE_CODE (node) == LABEL_DECL
144 && LABEL_DECL_UID (node) != -1)
146 if (dump_flags & TDF_NOUID)
147 fprintf (file, " L.xxxx");
148 else
149 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
151 else
153 if (dump_flags & TDF_NOUID)
154 fprintf (file, " %c.xxxx",
155 TREE_CODE (node) == CONST_DECL ? 'C' : 'D');
156 else
157 fprintf (file, " %c.%u",
158 TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
159 DECL_UID (node));
162 else if (tclass == tcc_type)
164 if (TYPE_NAME (node))
166 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
167 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
168 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
169 && DECL_NAME (TYPE_NAME (node)))
170 fprintf (file, " %s",
171 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
173 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
174 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
176 if (TREE_CODE (node) == IDENTIFIER_NODE)
177 fprintf (file, " %s", IDENTIFIER_POINTER (node));
179 /* We might as well always print the value of an integer or real. */
180 if (TREE_CODE (node) == INTEGER_CST)
182 if (TREE_OVERFLOW (node))
183 fprintf (file, " overflow");
185 fprintf (file, " ");
186 print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node)));
188 if (TREE_CODE (node) == REAL_CST)
189 print_real_cst (file, node, true);
190 if (TREE_CODE (node) == FIXED_CST)
192 FIXED_VALUE_TYPE f;
193 char string[60];
195 if (TREE_OVERFLOW (node))
196 fprintf (file, " overflow");
198 f = TREE_FIXED_CST (node);
199 fixed_to_decimal (string, &f, sizeof (string));
200 fprintf (file, " %s", string);
203 fprintf (file, ">");
206 void
207 indent_to (FILE *file, int column)
209 int i;
211 /* Since this is the long way, indent to desired column. */
212 if (column > 0)
213 fprintf (file, "\n");
214 for (i = 0; i < column; i++)
215 fprintf (file, " ");
218 /* Print the node NODE in full on file FILE, preceded by PREFIX,
219 starting in column INDENT. */
221 void
222 print_node (FILE *file, const char *prefix, tree node, int indent,
223 bool brief_for_visited)
225 machine_mode mode;
226 enum tree_code_class tclass;
227 int len;
228 int i;
229 expanded_location xloc;
230 enum tree_code code;
232 if (node == 0)
233 return;
235 code = TREE_CODE (node);
237 /* It is unsafe to look at any other fields of a node with ERROR_MARK or
238 invalid code. */
239 if (code == ERROR_MARK || code >= MAX_TREE_CODES)
241 print_node_brief (file, prefix, node, indent);
242 return;
245 tclass = TREE_CODE_CLASS (code);
247 /* Don't get too deep in nesting. If the user wants to see deeper,
248 it is easy to use the address of a lowest-level node
249 as an argument in another call to debug_tree. */
251 if (indent > 24)
253 print_node_brief (file, prefix, node, indent);
254 return;
257 if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
259 print_node_brief (file, prefix, node, indent);
260 return;
263 /* Allow this function to be called if the table is not there. */
264 if (table)
266 /* If node is in the table, just mention its address. */
267 if (table->contains (node) && brief_for_visited)
269 print_node_brief (file, prefix, node, indent);
270 return;
273 table->add (node);
276 /* Indent to the specified column, since this is the long form. */
277 indent_to (file, indent);
279 /* Print the slot this node is in, and its code, and address. */
280 fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
281 dump_addr (file, " ", node);
283 /* Print the name, if any. */
284 if (tclass == tcc_declaration)
286 if (DECL_NAME (node))
287 fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
288 else if (code == LABEL_DECL
289 && LABEL_DECL_UID (node) != -1)
291 if (dump_flags & TDF_NOUID)
292 fprintf (file, " L.xxxx");
293 else
294 fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
296 else
298 if (dump_flags & TDF_NOUID)
299 fprintf (file, " %c.xxxx", code == CONST_DECL ? 'C' : 'D');
300 else
301 fprintf (file, " %c.%u", code == CONST_DECL ? 'C' : 'D',
302 DECL_UID (node));
305 else if (tclass == tcc_type)
307 if (TYPE_NAME (node))
309 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
310 fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
311 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
312 && DECL_NAME (TYPE_NAME (node)))
313 fprintf (file, " %s",
314 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
317 if (code == IDENTIFIER_NODE)
318 fprintf (file, " %s", IDENTIFIER_POINTER (node));
320 if (code == INTEGER_CST)
322 if (indent <= 4)
323 print_node_brief (file, "type", TREE_TYPE (node), indent + 4);
325 else if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
327 print_node (file, "type", TREE_TYPE (node), indent + 4);
328 if (TREE_TYPE (node))
329 indent_to (file, indent + 3);
332 if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
333 fputs (" side-effects", file);
335 if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
336 fputs (" readonly", file);
337 if (TYPE_P (node) && TYPE_ATOMIC (node))
338 fputs (" atomic", file);
339 if (!TYPE_P (node) && TREE_CONSTANT (node))
340 fputs (" constant", file);
341 else if (TYPE_P (node) && TYPE_SIZES_GIMPLIFIED (node))
342 fputs (" sizes-gimplified", file);
344 if (TYPE_P (node) && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
345 fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
347 if (TREE_ADDRESSABLE (node))
348 fputs (" addressable", file);
349 if (TREE_THIS_VOLATILE (node))
350 fputs (" volatile", file);
351 if (TREE_ASM_WRITTEN (node))
352 fputs (" asm_written", file);
353 if (TREE_USED (node))
354 fputs (" used", file);
355 if (TREE_NOTHROW (node))
356 fputs (" nothrow", file);
357 if (TREE_PUBLIC (node))
358 fputs (" public", file);
359 if (TREE_PRIVATE (node))
360 fputs (" private", file);
361 if (TREE_PROTECTED (node))
362 fputs (" protected", file);
363 if (TREE_STATIC (node))
364 fputs (code == CALL_EXPR ? " must-tail-call" : " static", file);
365 if (TREE_DEPRECATED (node))
366 fputs (" deprecated", file);
367 if (TREE_VISITED (node))
368 fputs (" visited", file);
370 if (code != TREE_VEC && code != INTEGER_CST && code != SSA_NAME)
372 if (TREE_LANG_FLAG_0 (node))
373 fputs (" tree_0", file);
374 if (TREE_LANG_FLAG_1 (node))
375 fputs (" tree_1", file);
376 if (TREE_LANG_FLAG_2 (node))
377 fputs (" tree_2", file);
378 if (TREE_LANG_FLAG_3 (node))
379 fputs (" tree_3", file);
380 if (TREE_LANG_FLAG_4 (node))
381 fputs (" tree_4", file);
382 if (TREE_LANG_FLAG_5 (node))
383 fputs (" tree_5", file);
384 if (TREE_LANG_FLAG_6 (node))
385 fputs (" tree_6", file);
388 /* DECL_ nodes have additional attributes. */
390 switch (TREE_CODE_CLASS (code))
392 case tcc_declaration:
393 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
395 if (DECL_UNSIGNED (node))
396 fputs (" unsigned", file);
397 if (DECL_IGNORED_P (node))
398 fputs (" ignored", file);
399 if (DECL_ABSTRACT_P (node))
400 fputs (" abstract", file);
401 if (DECL_EXTERNAL (node))
402 fputs (" external", file);
403 if (DECL_NONLOCAL (node))
404 fputs (" nonlocal", file);
406 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
408 if (DECL_WEAK (node))
409 fputs (" weak", file);
410 if (DECL_IN_SYSTEM_HEADER (node))
411 fputs (" in_system_header", file);
413 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)
414 && code != LABEL_DECL
415 && code != FUNCTION_DECL
416 && DECL_REGISTER (node))
417 fputs (" regdecl", file);
419 if (code == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
420 fputs (" suppress-debug", file);
422 if (code == FUNCTION_DECL
423 && DECL_FUNCTION_SPECIFIC_TARGET (node))
424 fputs (" function-specific-target", file);
425 if (code == FUNCTION_DECL
426 && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node))
427 fputs (" function-specific-opt", file);
428 if (code == FUNCTION_DECL && DECL_DECLARED_INLINE_P (node))
429 fputs (" autoinline", file);
430 if (code == FUNCTION_DECL && DECL_UNINLINABLE (node))
431 fputs (" uninlinable", file);
432 if (code == FUNCTION_DECL && fndecl_built_in_p (node))
433 fputs (" built-in", file);
434 if (code == FUNCTION_DECL && DECL_STATIC_CHAIN (node))
435 fputs (" static-chain", file);
436 if (TREE_CODE (node) == FUNCTION_DECL && decl_is_tm_clone (node))
437 fputs (" tm-clone", file);
439 if (code == FIELD_DECL && DECL_PACKED (node))
440 fputs (" packed", file);
441 if (code == FIELD_DECL && DECL_BIT_FIELD (node))
442 fputs (" bit-field", file);
443 if (code == FIELD_DECL && DECL_NONADDRESSABLE_P (node))
444 fputs (" nonaddressable", file);
446 if (code == LABEL_DECL && EH_LANDING_PAD_NR (node))
447 fprintf (file, " landing-pad:%d", EH_LANDING_PAD_NR (node));
449 if (code == VAR_DECL && DECL_IN_TEXT_SECTION (node))
450 fputs (" in-text-section", file);
451 if (code == VAR_DECL && DECL_IN_CONSTANT_POOL (node))
452 fputs (" in-constant-pool", file);
453 if (code == VAR_DECL && DECL_COMMON (node))
454 fputs (" common", file);
455 if ((code == VAR_DECL || code == PARM_DECL) && DECL_READ_P (node))
456 fputs (" read", file);
457 if (code == VAR_DECL && DECL_THREAD_LOCAL_P (node))
459 fputs (" ", file);
460 fputs (tls_model_names[DECL_TLS_MODEL (node)], file);
463 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
465 if (DECL_VIRTUAL_P (node))
466 fputs (" virtual", file);
467 if (DECL_PRESERVE_P (node))
468 fputs (" preserve", file);
469 if (DECL_LANG_FLAG_0 (node))
470 fputs (" decl_0", file);
471 if (DECL_LANG_FLAG_1 (node))
472 fputs (" decl_1", file);
473 if (DECL_LANG_FLAG_2 (node))
474 fputs (" decl_2", file);
475 if (DECL_LANG_FLAG_3 (node))
476 fputs (" decl_3", file);
477 if (DECL_LANG_FLAG_4 (node))
478 fputs (" decl_4", file);
479 if (DECL_LANG_FLAG_5 (node))
480 fputs (" decl_5", file);
481 if (DECL_LANG_FLAG_6 (node))
482 fputs (" decl_6", file);
483 if (DECL_LANG_FLAG_7 (node))
484 fputs (" decl_7", file);
486 mode = DECL_MODE (node);
487 fprintf (file, " %s", GET_MODE_NAME (mode));
490 if ((code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
491 && DECL_BY_REFERENCE (node))
492 fputs (" passed-by-reference", file);
494 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS) && DECL_DEFER_OUTPUT (node))
495 fputs (" defer-output", file);
498 xloc = expand_location (DECL_SOURCE_LOCATION (node));
499 fprintf (file, " %s:%d:%d", xloc.file, xloc.line,
500 xloc.column);
502 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
504 print_node (file, "size", DECL_SIZE (node), indent + 4);
505 print_node (file, "unit-size", DECL_SIZE_UNIT (node), indent + 4);
507 if (code != FUNCTION_DECL || fndecl_built_in_p (node))
508 indent_to (file, indent + 3);
510 if (DECL_USER_ALIGN (node))
511 fprintf (file, " user");
513 fprintf (file, " align:%d warn_if_not_align:%d",
514 DECL_ALIGN (node), DECL_WARN_IF_NOT_ALIGN (node));
515 if (code == FIELD_DECL)
516 fprintf (file, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED,
517 DECL_OFFSET_ALIGN (node));
519 if (code == FUNCTION_DECL && fndecl_built_in_p (node))
521 if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_MD)
522 fprintf (file, " built-in: BUILT_IN_MD:%d",
523 DECL_MD_FUNCTION_CODE (node));
524 else if (DECL_BUILT_IN_CLASS (node) == BUILT_IN_FRONTEND)
525 fprintf (file, " built-in: BUILT_IN_FRONTEND:%d",
526 DECL_FE_FUNCTION_CODE (node));
527 else
528 fprintf (file, " built-in: %s:%s",
529 built_in_class_names[(int) DECL_BUILT_IN_CLASS (node)],
530 built_in_names[(int) DECL_FUNCTION_CODE (node)]);
533 if (code == FIELD_DECL)
535 print_node (file, "offset", DECL_FIELD_OFFSET (node), indent + 4);
536 print_node (file, "bit-offset", DECL_FIELD_BIT_OFFSET (node),
537 indent + 4);
538 if (DECL_BIT_FIELD_TYPE (node))
539 print_node (file, "bit_field_type", DECL_BIT_FIELD_TYPE (node),
540 indent + 4);
543 print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
545 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
547 print_node (file, "attributes",
548 DECL_ATTRIBUTES (node), indent + 4);
549 if (code != PARM_DECL)
550 print_node_brief (file, "initial", DECL_INITIAL (node),
551 indent + 4);
553 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
555 print_node_brief (file, "abstract_origin",
556 DECL_ABSTRACT_ORIGIN (node), indent + 4);
558 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
560 print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
563 lang_hooks.print_decl (file, node, indent);
565 if (DECL_RTL_SET_P (node))
567 indent_to (file, indent + 4);
568 print_rtl (file, DECL_RTL (node));
571 if (code == PARM_DECL)
573 print_node (file, "arg-type", DECL_ARG_TYPE (node), indent + 4);
575 if (DECL_INCOMING_RTL (node) != 0)
577 indent_to (file, indent + 4);
578 fprintf (file, "incoming-rtl ");
579 print_rtl (file, DECL_INCOMING_RTL (node));
582 else if (code == FUNCTION_DECL
583 && DECL_STRUCT_FUNCTION (node) != 0)
585 print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
586 indent_to (file, indent + 4);
587 dump_addr (file, "struct-function ", DECL_STRUCT_FUNCTION (node));
590 if ((code == VAR_DECL || code == PARM_DECL)
591 && DECL_HAS_VALUE_EXPR_P (node))
592 print_node (file, "value-expr", DECL_VALUE_EXPR (node), indent + 4);
594 /* Print the decl chain only if decl is at second level. */
595 if (indent == 4)
596 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
597 else
598 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
599 break;
601 case tcc_type:
602 if (TYPE_UNSIGNED (node))
603 fputs (" unsigned", file);
605 if (TYPE_NO_FORCE_BLK (node))
606 fputs (" no-force-blk", file);
608 if (code == ARRAY_TYPE && TYPE_STRING_FLAG (node))
609 fputs (" string-flag", file);
611 if (TYPE_NEEDS_CONSTRUCTING (node))
612 fputs (" needs-constructing", file);
614 if ((code == RECORD_TYPE
615 || code == UNION_TYPE
616 || code == QUAL_UNION_TYPE
617 || code == ARRAY_TYPE)
618 && TYPE_REVERSE_STORAGE_ORDER (node))
619 fputs (" reverse-storage-order", file);
621 if ((code == RECORD_TYPE
622 || code == UNION_TYPE)
623 && TYPE_CXX_ODR_P (node))
624 fputs (" cxx-odr-p", file);
626 /* The transparent-union flag is used for different things in
627 different nodes. */
628 if ((code == UNION_TYPE || code == RECORD_TYPE)
629 && TYPE_TRANSPARENT_AGGR (node))
630 fputs (" transparent-aggr", file);
631 else if (code == ARRAY_TYPE
632 && TYPE_NONALIASED_COMPONENT (node))
633 fputs (" nonaliased-component", file);
635 if (TYPE_PACKED (node))
636 fputs (" packed", file);
638 if (TYPE_RESTRICT (node))
639 fputs (" restrict", file);
641 if (TYPE_LANG_FLAG_0 (node))
642 fputs (" type_0", file);
643 if (TYPE_LANG_FLAG_1 (node))
644 fputs (" type_1", file);
645 if (TYPE_LANG_FLAG_2 (node))
646 fputs (" type_2", file);
647 if (TYPE_LANG_FLAG_3 (node))
648 fputs (" type_3", file);
649 if (TYPE_LANG_FLAG_4 (node))
650 fputs (" type_4", file);
651 if (TYPE_LANG_FLAG_5 (node))
652 fputs (" type_5", file);
653 if (TYPE_LANG_FLAG_6 (node))
654 fputs (" type_6", file);
655 if (TYPE_LANG_FLAG_7 (node))
656 fputs (" type_7", file);
658 mode = TYPE_MODE (node);
659 fprintf (file, " %s", GET_MODE_NAME (mode));
661 print_node (file, "size", TYPE_SIZE (node), indent + 4);
662 print_node (file, "unit-size", TYPE_SIZE_UNIT (node), indent + 4);
663 indent_to (file, indent + 3);
665 if (TYPE_USER_ALIGN (node))
666 fprintf (file, " user");
668 fprintf (file, " align:%d warn_if_not_align:%d symtab:%d alias-set "
669 HOST_WIDE_INT_PRINT_DEC,
670 TYPE_ALIGN (node), TYPE_WARN_IF_NOT_ALIGN (node),
671 TYPE_SYMTAB_ADDRESS (node),
672 (HOST_WIDE_INT) TYPE_ALIAS_SET (node));
674 if (TYPE_STRUCTURAL_EQUALITY_P (node))
675 fprintf (file, " structural-equality");
676 else
677 dump_addr (file, " canonical-type ", TYPE_CANONICAL (node));
679 print_node (file, "attributes", TYPE_ATTRIBUTES (node), indent + 4);
681 if (INTEGRAL_TYPE_P (node) || code == REAL_TYPE
682 || code == FIXED_POINT_TYPE)
684 fprintf (file, " precision:%d", TYPE_PRECISION (node));
685 print_node_brief (file, "min", TYPE_MIN_VALUE (node), indent + 4);
686 print_node_brief (file, "max", TYPE_MAX_VALUE (node), indent + 4);
689 if (code == ENUMERAL_TYPE)
690 print_node (file, "values", TYPE_VALUES (node), indent + 4);
691 else if (code == ARRAY_TYPE)
692 print_node (file, "domain", TYPE_DOMAIN (node), indent + 4);
693 else if (code == VECTOR_TYPE)
695 fprintf (file, " nunits:");
696 print_dec (TYPE_VECTOR_SUBPARTS (node), file);
698 else if (code == RECORD_TYPE
699 || code == UNION_TYPE
700 || code == QUAL_UNION_TYPE)
701 print_node (file, "fields", TYPE_FIELDS (node), indent + 4);
702 else if (code == FUNCTION_TYPE
703 || code == METHOD_TYPE)
705 if (TYPE_METHOD_BASETYPE (node))
706 print_node_brief (file, "method basetype",
707 TYPE_METHOD_BASETYPE (node), indent + 4);
708 print_node (file, "arg-types", TYPE_ARG_TYPES (node), indent + 4);
710 else if (code == OFFSET_TYPE)
711 print_node_brief (file, "basetype", TYPE_OFFSET_BASETYPE (node),
712 indent + 4);
714 if (TYPE_CONTEXT (node))
715 print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4);
717 lang_hooks.print_type (file, node, indent);
719 if (TYPE_POINTER_TO (node) || TREE_CHAIN (node))
720 indent_to (file, indent + 3);
722 print_node_brief (file, "pointer_to_this", TYPE_POINTER_TO (node),
723 indent + 4);
724 print_node_brief (file, "reference_to_this", TYPE_REFERENCE_TO (node),
725 indent + 4);
726 print_node_brief (file, "chain", TREE_CHAIN (node), indent + 4);
727 break;
729 case tcc_expression:
730 case tcc_comparison:
731 case tcc_unary:
732 case tcc_binary:
733 case tcc_reference:
734 case tcc_statement:
735 case tcc_vl_exp:
736 if (code == BIND_EXPR)
738 print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
739 print_node (file, "body", TREE_OPERAND (node, 1), indent + 4);
740 print_node (file, "block", TREE_OPERAND (node, 2), indent + 4);
741 break;
743 if (code == CALL_EXPR)
745 call_expr_arg_iterator iter;
746 tree arg;
747 print_node (file, "fn", CALL_EXPR_FN (node), indent + 4);
748 print_node (file, "static_chain", CALL_EXPR_STATIC_CHAIN (node),
749 indent + 4);
750 i = 0;
751 FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
753 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
754 the text. */
755 char temp[15];
756 sprintf (temp, "arg:%u", i);
757 print_node (file, temp, arg, indent + 4);
758 i++;
761 else
763 len = TREE_OPERAND_LENGTH (node);
765 for (i = 0; i < len; i++)
767 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
768 the text. */
769 char temp[15];
771 sprintf (temp, "arg:%d", i);
772 print_node (file, temp, TREE_OPERAND (node, i), indent + 4);
775 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
776 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
777 break;
779 case tcc_constant:
780 case tcc_exceptional:
781 switch (code)
783 case INTEGER_CST:
784 if (TREE_OVERFLOW (node))
785 fprintf (file, " overflow");
787 fprintf (file, " ");
788 print_dec (wi::to_wide (node), file, TYPE_SIGN (TREE_TYPE (node)));
789 break;
791 case REAL_CST:
792 print_real_cst (file, node, false);
793 break;
795 case FIXED_CST:
797 FIXED_VALUE_TYPE f;
798 char string[64];
800 if (TREE_OVERFLOW (node))
801 fprintf (file, " overflow");
803 f = TREE_FIXED_CST (node);
804 fixed_to_decimal (string, &f, sizeof (string));
805 fprintf (file, " %s", string);
807 break;
809 case VECTOR_CST:
811 /* Big enough for UINT_MAX plus the string below. */
812 char buf[32];
814 fprintf (file, " npatterns:%u nelts-per-pattern:%u",
815 VECTOR_CST_NPATTERNS (node),
816 VECTOR_CST_NELTS_PER_PATTERN (node));
817 unsigned int count = vector_cst_encoded_nelts (node);
818 for (unsigned int i = 0; i < count; ++i)
820 sprintf (buf, "elt:%u: ", i);
821 print_node (file, buf, VECTOR_CST_ENCODED_ELT (node, i),
822 indent + 4);
825 break;
827 case COMPLEX_CST:
828 print_node (file, "real", TREE_REALPART (node), indent + 4);
829 print_node (file, "imag", TREE_IMAGPART (node), indent + 4);
830 break;
832 case STRING_CST:
834 const char *p = TREE_STRING_POINTER (node);
835 int i = TREE_STRING_LENGTH (node);
836 fputs (" \"", file);
837 while (--i >= 0)
839 char ch = *p++;
840 if (ch >= ' ' && ch < 127)
841 putc (ch, file);
842 else
843 fprintf (file, "\\%03o", ch & 0xFF);
845 fputc ('\"', file);
847 break;
849 case POLY_INT_CST:
851 char buf[10];
852 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
854 snprintf (buf, sizeof (buf), "elt%u: ", i);
855 print_node (file, buf, POLY_INT_CST_COEFF (node, i),
856 indent + 4);
859 break;
861 case IDENTIFIER_NODE:
862 lang_hooks.print_identifier (file, node, indent);
863 break;
865 case TREE_LIST:
866 print_node (file, "purpose", TREE_PURPOSE (node), indent + 4);
867 print_node (file, "value", TREE_VALUE (node), indent + 4);
868 print_node (file, "chain", TREE_CHAIN (node), indent + 4);
869 break;
871 case TREE_VEC:
872 len = TREE_VEC_LENGTH (node);
873 fprintf (file, " length:%d", len);
874 for (i = 0; i < len; i++)
875 if (TREE_VEC_ELT (node, i))
877 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
878 the text. */
879 char temp[15];
880 sprintf (temp, "elt:%d", i);
881 print_node (file, temp, TREE_VEC_ELT (node, i), indent + 4);
883 break;
885 case CONSTRUCTOR:
887 unsigned HOST_WIDE_INT cnt;
888 tree index, value;
889 len = CONSTRUCTOR_NELTS (node);
890 fprintf (file, " length:%d", len);
891 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node),
892 cnt, index, value)
894 print_node (file, "idx", index, indent + 4, false);
895 print_node (file, "val", value, indent + 4, false);
898 break;
900 case STATEMENT_LIST:
901 dump_addr (file, " head ", node->stmt_list.head);
902 dump_addr (file, " tail ", node->stmt_list.tail);
903 fprintf (file, " stmts");
905 tree_stmt_iterator i;
906 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
908 /* Not printing the addresses of the (not-a-tree)
909 'struct tree_stmt_list_node's. */
910 dump_addr (file, " ", tsi_stmt (i));
912 fprintf (file, "\n");
913 for (i = tsi_start (node); !tsi_end_p (i); tsi_next (&i))
915 /* Not printing the addresses of the (not-a-tree)
916 'struct tree_stmt_list_node's. */
917 print_node (file, "stmt", tsi_stmt (i), indent + 4);
920 break;
922 case BLOCK:
923 print_node (file, "vars", BLOCK_VARS (node), indent + 4);
924 print_node (file, "supercontext", BLOCK_SUPERCONTEXT (node),
925 indent + 4);
926 print_node (file, "subblocks", BLOCK_SUBBLOCKS (node), indent + 4);
927 print_node (file, "chain", BLOCK_CHAIN (node), indent + 4);
928 print_node (file, "abstract_origin",
929 BLOCK_ABSTRACT_ORIGIN (node), indent + 4);
930 break;
932 case SSA_NAME:
933 print_node_brief (file, "var", SSA_NAME_VAR (node), indent + 4);
934 indent_to (file, indent + 4);
935 fprintf (file, "def_stmt ");
937 pretty_printer buffer;
938 buffer.buffer->stream = file;
939 pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4,
940 TDF_NONE);
941 pp_flush (&buffer);
944 indent_to (file, indent + 4);
945 fprintf (file, "version:%u", SSA_NAME_VERSION (node));
946 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
947 fprintf (file, " in-abnormal-phi");
948 if (SSA_NAME_IN_FREE_LIST (node))
949 fprintf (file, " in-free-list");
951 if (SSA_NAME_PTR_INFO (node))
953 indent_to (file, indent + 3);
954 if (SSA_NAME_PTR_INFO (node))
955 dump_addr (file, " ptr-info ", SSA_NAME_PTR_INFO (node));
957 break;
959 case OMP_CLAUSE:
961 int i;
962 fprintf (file, " %s",
963 omp_clause_code_name[OMP_CLAUSE_CODE (node)]);
964 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (node)]; i++)
966 indent_to (file, indent + 4);
967 fprintf (file, "op-%d:", i);
968 print_node_brief (file, "", OMP_CLAUSE_OPERAND (node, i), 0);
971 break;
973 case OPTIMIZATION_NODE:
974 cl_optimization_print (file, indent + 4, TREE_OPTIMIZATION (node));
975 break;
977 case TARGET_OPTION_NODE:
978 cl_target_option_print (file, indent + 4, TREE_TARGET_OPTION (node));
979 break;
980 case IMPORTED_DECL:
981 fprintf (file, " imported-declaration");
982 print_node_brief (file, "associated-declaration",
983 IMPORTED_DECL_ASSOCIATED_DECL (node),
984 indent + 4);
985 break;
987 case TREE_BINFO:
988 fprintf (file, " bases:%d",
989 vec_safe_length (BINFO_BASE_BINFOS (node)));
990 print_node_brief (file, "offset", BINFO_OFFSET (node), indent + 4);
991 print_node_brief (file, "virtuals", BINFO_VIRTUALS (node),
992 indent + 4);
993 print_node_brief (file, "inheritance-chain",
994 BINFO_INHERITANCE_CHAIN (node),
995 indent + 4);
996 break;
998 default:
999 if (EXCEPTIONAL_CLASS_P (node))
1000 lang_hooks.print_xnode (file, node, indent);
1001 break;
1004 break;
1007 if (EXPR_HAS_LOCATION (node))
1009 expanded_location xloc = expand_location (EXPR_LOCATION (node));
1010 indent_to (file, indent+4);
1011 fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column);
1013 /* Print the range, if any */
1014 source_range r = EXPR_LOCATION_RANGE (node);
1015 if (r.m_start)
1017 xloc = expand_location (r.m_start);
1018 fprintf (file, " start: %s:%d:%d", xloc.file, xloc.line, xloc.column);
1020 else
1022 fprintf (file, " start: unknown");
1024 if (r.m_finish)
1026 xloc = expand_location (r.m_finish);
1027 fprintf (file, " finish: %s:%d:%d", xloc.file, xloc.line, xloc.column);
1029 else
1031 fprintf (file, " finish: unknown");
1035 fprintf (file, ">");
1038 /* Print the identifier for DECL according to FLAGS. */
1040 void
1041 print_decl_identifier (FILE *file, tree decl, int flags)
1043 bool needs_colon = false;
1044 const char *name;
1045 char c;
1047 if (flags & PRINT_DECL_ORIGIN)
1049 if (DECL_IS_BUILTIN (decl))
1050 fputs ("<built-in>", file);
1051 else
1053 expanded_location loc
1054 = expand_location (DECL_SOURCE_LOCATION (decl));
1055 fprintf (file, "%s:%d:%d", loc.file, loc.line, loc.column);
1057 needs_colon = true;
1060 if (flags & PRINT_DECL_UNIQUE_NAME)
1062 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1063 if (!TREE_PUBLIC (decl)
1064 || (DECL_WEAK (decl) && !DECL_EXTERNAL (decl)))
1065 /* The symbol has internal or weak linkage so its assembler name
1066 is not necessarily unique among the compilation units of the
1067 program. We therefore have to further mangle it. But we can't
1068 simply use DECL_SOURCE_FILE because it contains the name of the
1069 file the symbol originates from so, e.g. for function templates
1070 in C++ where the templates are defined in a header file, we can
1071 have symbols with the same assembler name and DECL_SOURCE_FILE.
1072 That's why we use the name of the top-level source file of the
1073 compilation unit. ??? Unnecessary for Ada. */
1074 name = ACONCAT ((main_input_filename, ":", name, NULL));
1076 else if (flags & PRINT_DECL_NAME)
1078 /* We don't want to print the full qualified name because it can be long,
1079 so we strip the scope prefix, but we may need to deal with the suffix
1080 created by the compiler. */
1081 const char *suffix = strchr (IDENTIFIER_POINTER (DECL_NAME (decl)), '.');
1082 name = lang_hooks.decl_printable_name (decl, 2);
1083 if (suffix)
1085 const char *dot = strchr (name, '.');
1086 while (dot && strcasecmp (dot, suffix) != 0)
1088 name = dot + 1;
1089 dot = strchr (name, '.');
1092 else
1094 const char *dot = strrchr (name, '.');
1095 if (dot)
1096 name = dot + 1;
1099 else
1100 return;
1102 if (needs_colon)
1103 fputc (':', file);
1105 while ((c = *name++) != '\0')
1107 /* Strip double-quotes because of VCG. */
1108 if (c == '"')
1109 continue;
1110 fputc (c, file);
1115 /* Print the node NODE on standard error, for debugging.
1116 Most nodes referred to by this one are printed recursively
1117 down to a depth of six. */
1119 DEBUG_FUNCTION void
1120 debug_tree (tree node)
1122 table = new hash_set<tree> (HASH_SIZE);
1123 print_node (stderr, "", node, 0);
1124 delete table;
1125 table = NULL;
1126 putc ('\n', stderr);
1129 DEBUG_FUNCTION void
1130 debug_raw (const tree_node &ref)
1132 debug_tree (const_cast <tree> (&ref));
1135 DEBUG_FUNCTION void
1136 debug_raw (const tree_node *ptr)
1138 if (ptr)
1139 debug_raw (*ptr);
1140 else
1141 fprintf (stderr, "<nil>\n");
1144 static void
1145 dump_tree_via_hooks (const tree_node *ptr, dump_flags_t options)
1147 if (DECL_P (ptr))
1148 lang_hooks.print_decl (stderr, const_cast <tree_node*> (ptr), 0);
1149 else if (TYPE_P (ptr))
1150 lang_hooks.print_type (stderr, const_cast <tree_node*> (ptr), 0);
1151 else if (TREE_CODE (ptr) == IDENTIFIER_NODE)
1152 lang_hooks.print_identifier (stderr, const_cast <tree_node*> (ptr), 0);
1153 else
1154 print_generic_expr (stderr, const_cast <tree_node*> (ptr), options);
1155 fprintf (stderr, "\n");
1158 DEBUG_FUNCTION void
1159 debug (const tree_node &ref)
1161 dump_tree_via_hooks (&ref, TDF_NONE);
1164 DEBUG_FUNCTION void
1165 debug (const tree_node *ptr)
1167 if (ptr)
1168 debug (*ptr);
1169 else
1170 fprintf (stderr, "<nil>\n");
1173 DEBUG_FUNCTION void
1174 debug_head (const tree_node &ref)
1176 debug (ref);
1179 DEBUG_FUNCTION void
1180 debug_head (const tree_node *ptr)
1182 if (ptr)
1183 debug_head (*ptr);
1184 else
1185 fprintf (stderr, "<nil>\n");
1188 DEBUG_FUNCTION void
1189 debug_body (const tree_node &ref)
1191 if (TREE_CODE (&ref) == FUNCTION_DECL)
1192 dump_function_to_file (const_cast <tree_node*> (&ref), stderr, TDF_NONE);
1193 else
1194 debug (ref);
1197 DEBUG_FUNCTION void
1198 debug_body (const tree_node *ptr)
1200 if (ptr)
1201 debug_body (*ptr);
1202 else
1203 fprintf (stderr, "<nil>\n");
1206 /* Print the vector of trees VEC on standard error, for debugging.
1207 Most nodes referred to by this one are printed recursively
1208 down to a depth of six. */
1210 DEBUG_FUNCTION void
1211 debug_raw (vec<tree, va_gc> &ref)
1213 tree elt;
1214 unsigned ix;
1216 /* Print the slot this node is in, and its code, and address. */
1217 fprintf (stderr, "<VEC");
1218 dump_addr (stderr, " ", ref.address ());
1220 FOR_EACH_VEC_ELT (ref, ix, elt)
1222 fprintf (stderr, "elt:%d ", ix);
1223 debug_raw (elt);
1227 DEBUG_FUNCTION void
1228 debug_raw (vec<tree, va_gc> *ptr)
1230 if (ptr)
1231 debug_raw (*ptr);
1232 else
1233 fprintf (stderr, "<nil>\n");
1236 static void
1237 debug_slim (tree t)
1239 print_node_brief (stderr, "", t, 0);
1242 DEFINE_DEBUG_VEC (tree)
1243 DEFINE_DEBUG_HASH_SET (tree)