1 /* Prints out tree in human readable form - GCC
2 Copyright (C) 1990-2021 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
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
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/>. */
23 #include "coretypes.h"
27 #include "diagnostic.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 */
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. */
43 static hash_set
<tree
> *table
= NULL
;
45 /* Print PREFIX and ADDR to FILE. */
47 dump_addr (FILE *file
, const char *prefix
, const void *addr
)
49 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
50 fprintf (file
, "%s#", prefix
);
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. */
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. */
74 const char *psig
= (const char *) d
.sig
;
75 for (unsigned i
= 0; i
!= sizeof d
.sig
; ++i
)
82 fprintf (file
, " %s%sNaN", d
.sign
? "-" : "",
83 d
.signalling
? "S" : "Q");
89 fprintf (file
, "(0x%s", d
.canonical
? "" : "0");
91 fprintf (file
, "(%s", d
.canonical
? "" : "0");
92 else if (!d
.canonical
)
94 fprintf (file
, "(0)");
100 for (unsigned i
= start
; i
!= sizeof d
.sig
; ++i
)
102 fprintf (file
, "%x", psig
[i
]);
104 fprintf (file
, "%02x", psig
[i
]);
108 fprintf (file
, "%se%u)", psig
[start
] ? "," : "", d
.uexp
);
109 else if (psig
[start
])
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. */
123 print_node_brief (FILE *file
, const char *prefix
, const_tree node
, int indent
)
125 enum tree_code_class tclass
;
130 tclass
= TREE_CODE_CLASS (TREE_CODE (node
));
132 /* Always print the slot this node is in, and its code, address and
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");
149 fprintf (file
, " L.%d", (int) LABEL_DECL_UID (node
));
153 if (dump_flags
& TDF_NOUID
)
154 fprintf (file
, " %c.xxxx",
155 TREE_CODE (node
) == CONST_DECL
? 'C' : 'D');
157 fprintf (file
, " %c.%u",
158 TREE_CODE (node
) == CONST_DECL
? 'C' : 'D',
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");
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
)
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
);
207 indent_to (FILE *file
, int column
)
211 /* Since this is the long way, indent to desired column. */
213 fprintf (file
, "\n");
214 for (i
= 0; i
< column
; i
++)
218 /* Print the node NODE in full on file FILE, preceded by PREFIX,
219 starting in column INDENT. */
222 print_node (FILE *file
, const char *prefix
, tree node
, int indent
,
223 bool brief_for_visited
)
226 enum tree_code_class tclass
;
229 expanded_location xloc
;
235 code
= TREE_CODE (node
);
237 /* It is unsafe to look at any other fields of a node with ERROR_MARK or
239 if (code
== ERROR_MARK
|| code
>= MAX_TREE_CODES
)
241 print_node_brief (file
, prefix
, node
, indent
);
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. */
253 print_node_brief (file
, prefix
, node
, indent
);
257 if (indent
> 8 && (tclass
== tcc_type
|| tclass
== tcc_declaration
))
259 print_node_brief (file
, prefix
, node
, indent
);
263 /* Allow this function to be called if the table is not there. */
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
);
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");
294 fprintf (file
, " L.%d", (int) LABEL_DECL_UID (node
));
298 if (dump_flags
& TDF_NOUID
)
299 fprintf (file
, " %c.xxxx", code
== CONST_DECL
? 'C' : 'D');
301 fprintf (file
, " %c.%u", code
== CONST_DECL
? 'C' : 'D',
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
)
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_UNAVAILABLE (node
))
368 fputs (" unavailable", file
);
369 if (TREE_VISITED (node
))
370 fputs (" visited", file
);
372 if (code
!= TREE_VEC
&& code
!= INTEGER_CST
&& code
!= SSA_NAME
)
374 if (TREE_LANG_FLAG_0 (node
))
375 fputs (" tree_0", file
);
376 if (TREE_LANG_FLAG_1 (node
))
377 fputs (" tree_1", file
);
378 if (TREE_LANG_FLAG_2 (node
))
379 fputs (" tree_2", file
);
380 if (TREE_LANG_FLAG_3 (node
))
381 fputs (" tree_3", file
);
382 if (TREE_LANG_FLAG_4 (node
))
383 fputs (" tree_4", file
);
384 if (TREE_LANG_FLAG_5 (node
))
385 fputs (" tree_5", file
);
386 if (TREE_LANG_FLAG_6 (node
))
387 fputs (" tree_6", file
);
390 /* DECL_ nodes have additional attributes. */
392 switch (TREE_CODE_CLASS (code
))
394 case tcc_declaration
:
395 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
397 if (DECL_UNSIGNED (node
))
398 fputs (" unsigned", file
);
399 if (DECL_IGNORED_P (node
))
400 fputs (" ignored", file
);
401 if (DECL_ABSTRACT_P (node
))
402 fputs (" abstract", file
);
403 if (DECL_EXTERNAL (node
))
404 fputs (" external", file
);
405 if (DECL_NONLOCAL (node
))
406 fputs (" nonlocal", file
);
408 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
410 if (DECL_WEAK (node
))
411 fputs (" weak", file
);
412 if (DECL_IN_SYSTEM_HEADER (node
))
413 fputs (" in_system_header", file
);
415 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
)
416 && code
!= LABEL_DECL
417 && code
!= FUNCTION_DECL
418 && DECL_REGISTER (node
))
419 fputs (" regdecl", file
);
421 if (code
== TYPE_DECL
&& TYPE_DECL_SUPPRESS_DEBUG (node
))
422 fputs (" suppress-debug", file
);
424 if (code
== FUNCTION_DECL
425 && DECL_FUNCTION_SPECIFIC_TARGET (node
))
426 fputs (" function-specific-target", file
);
427 if (code
== FUNCTION_DECL
428 && DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node
))
429 fputs (" function-specific-opt", file
);
430 if (code
== FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (node
))
431 fputs (" autoinline", file
);
432 if (code
== FUNCTION_DECL
&& DECL_UNINLINABLE (node
))
433 fputs (" uninlinable", file
);
434 if (code
== FUNCTION_DECL
&& fndecl_built_in_p (node
))
435 fputs (" built-in", file
);
436 if (code
== FUNCTION_DECL
&& DECL_STATIC_CHAIN (node
))
437 fputs (" static-chain", file
);
438 if (TREE_CODE (node
) == FUNCTION_DECL
&& decl_is_tm_clone (node
))
439 fputs (" tm-clone", file
);
441 if (code
== FIELD_DECL
&& DECL_PACKED (node
))
442 fputs (" packed", file
);
443 if (code
== FIELD_DECL
&& DECL_BIT_FIELD (node
))
444 fputs (" bit-field", file
);
445 if (code
== FIELD_DECL
&& DECL_NONADDRESSABLE_P (node
))
446 fputs (" nonaddressable", file
);
448 if (code
== LABEL_DECL
&& EH_LANDING_PAD_NR (node
))
449 fprintf (file
, " landing-pad:%d", EH_LANDING_PAD_NR (node
));
451 if (code
== VAR_DECL
&& DECL_IN_TEXT_SECTION (node
))
452 fputs (" in-text-section", file
);
453 if (code
== VAR_DECL
&& DECL_IN_CONSTANT_POOL (node
))
454 fputs (" in-constant-pool", file
);
455 if (code
== VAR_DECL
&& DECL_COMMON (node
))
456 fputs (" common", file
);
457 if ((code
== VAR_DECL
|| code
== PARM_DECL
) && DECL_READ_P (node
))
458 fputs (" read", file
);
459 if (code
== VAR_DECL
&& DECL_THREAD_LOCAL_P (node
))
462 fputs (tls_model_names
[DECL_TLS_MODEL (node
)], file
);
465 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
467 if (DECL_VIRTUAL_P (node
))
468 fputs (" virtual", file
);
469 if (DECL_PRESERVE_P (node
))
470 fputs (" preserve", file
);
471 if (DECL_LANG_FLAG_0 (node
))
472 fputs (" decl_0", file
);
473 if (DECL_LANG_FLAG_1 (node
))
474 fputs (" decl_1", file
);
475 if (DECL_LANG_FLAG_2 (node
))
476 fputs (" decl_2", file
);
477 if (DECL_LANG_FLAG_3 (node
))
478 fputs (" decl_3", file
);
479 if (DECL_LANG_FLAG_4 (node
))
480 fputs (" decl_4", file
);
481 if (DECL_LANG_FLAG_5 (node
))
482 fputs (" decl_5", file
);
483 if (DECL_LANG_FLAG_6 (node
))
484 fputs (" decl_6", file
);
485 if (DECL_LANG_FLAG_7 (node
))
486 fputs (" decl_7", file
);
488 mode
= DECL_MODE (node
);
489 fprintf (file
, " %s", GET_MODE_NAME (mode
));
492 if ((code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
493 && DECL_BY_REFERENCE (node
))
494 fputs (" passed-by-reference", file
);
496 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
) && DECL_DEFER_OUTPUT (node
))
497 fputs (" defer-output", file
);
500 xloc
= expand_location (DECL_SOURCE_LOCATION (node
));
501 fprintf (file
, " %s:%d:%d", xloc
.file
, xloc
.line
,
504 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
506 print_node (file
, "size", DECL_SIZE (node
), indent
+ 4);
507 print_node (file
, "unit-size", DECL_SIZE_UNIT (node
), indent
+ 4);
509 if (code
!= FUNCTION_DECL
|| fndecl_built_in_p (node
))
510 indent_to (file
, indent
+ 3);
512 if (DECL_USER_ALIGN (node
))
513 fprintf (file
, " user");
515 fprintf (file
, " align:%d warn_if_not_align:%d",
516 DECL_ALIGN (node
), DECL_WARN_IF_NOT_ALIGN (node
));
517 if (code
== FIELD_DECL
)
518 fprintf (file
, " offset_align " HOST_WIDE_INT_PRINT_UNSIGNED
,
519 DECL_OFFSET_ALIGN (node
));
521 if (code
== FUNCTION_DECL
&& fndecl_built_in_p (node
))
523 if (DECL_BUILT_IN_CLASS (node
) == BUILT_IN_MD
)
524 fprintf (file
, " built-in: BUILT_IN_MD:%d",
525 DECL_MD_FUNCTION_CODE (node
));
526 else if (DECL_BUILT_IN_CLASS (node
) == BUILT_IN_FRONTEND
)
527 fprintf (file
, " built-in: BUILT_IN_FRONTEND:%d",
528 DECL_FE_FUNCTION_CODE (node
));
530 fprintf (file
, " built-in: %s:%s",
531 built_in_class_names
[(int) DECL_BUILT_IN_CLASS (node
)],
532 built_in_names
[(int) DECL_FUNCTION_CODE (node
)]);
535 if (code
== FIELD_DECL
)
537 print_node (file
, "offset", DECL_FIELD_OFFSET (node
), indent
+ 4);
538 print_node (file
, "bit-offset", DECL_FIELD_BIT_OFFSET (node
),
540 if (DECL_BIT_FIELD_TYPE (node
))
541 print_node (file
, "bit_field_type", DECL_BIT_FIELD_TYPE (node
),
545 print_node_brief (file
, "context", DECL_CONTEXT (node
), indent
+ 4);
547 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
549 print_node (file
, "attributes",
550 DECL_ATTRIBUTES (node
), indent
+ 4);
551 if (code
!= PARM_DECL
)
552 print_node_brief (file
, "initial", DECL_INITIAL (node
),
555 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
557 print_node_brief (file
, "abstract_origin",
558 DECL_ABSTRACT_ORIGIN (node
), indent
+ 4);
560 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
562 print_node (file
, "result", DECL_RESULT_FLD (node
), indent
+ 4);
565 lang_hooks
.print_decl (file
, node
, indent
);
567 if (DECL_RTL_SET_P (node
))
569 indent_to (file
, indent
+ 4);
570 print_rtl (file
, DECL_RTL (node
));
573 if (code
== PARM_DECL
)
575 print_node (file
, "arg-type", DECL_ARG_TYPE (node
), indent
+ 4);
577 if (DECL_INCOMING_RTL (node
) != 0)
579 indent_to (file
, indent
+ 4);
580 fprintf (file
, "incoming-rtl ");
581 print_rtl (file
, DECL_INCOMING_RTL (node
));
584 else if (code
== FUNCTION_DECL
585 && DECL_STRUCT_FUNCTION (node
) != 0)
587 print_node (file
, "arguments", DECL_ARGUMENTS (node
), indent
+ 4);
588 indent_to (file
, indent
+ 4);
589 dump_addr (file
, "struct-function ", DECL_STRUCT_FUNCTION (node
));
592 if ((code
== VAR_DECL
|| code
== PARM_DECL
)
593 && DECL_HAS_VALUE_EXPR_P (node
))
594 print_node (file
, "value-expr", DECL_VALUE_EXPR (node
), indent
+ 4);
596 /* Print the decl chain only if decl is at second level. */
598 print_node (file
, "chain", TREE_CHAIN (node
), indent
+ 4);
600 print_node_brief (file
, "chain", TREE_CHAIN (node
), indent
+ 4);
604 if (TYPE_UNSIGNED (node
))
605 fputs (" unsigned", file
);
607 if (TYPE_NO_FORCE_BLK (node
))
608 fputs (" no-force-blk", file
);
610 if (code
== ARRAY_TYPE
&& TYPE_STRING_FLAG (node
))
611 fputs (" string-flag", file
);
613 if (TYPE_NEEDS_CONSTRUCTING (node
))
614 fputs (" needs-constructing", file
);
616 if ((code
== RECORD_TYPE
617 || code
== UNION_TYPE
618 || code
== QUAL_UNION_TYPE
619 || code
== ARRAY_TYPE
)
620 && TYPE_REVERSE_STORAGE_ORDER (node
))
621 fputs (" reverse-storage-order", file
);
623 if ((code
== RECORD_TYPE
624 || code
== UNION_TYPE
)
625 && TYPE_CXX_ODR_P (node
))
626 fputs (" cxx-odr-p", file
);
628 /* The transparent-union flag is used for different things in
630 if ((code
== UNION_TYPE
|| code
== RECORD_TYPE
)
631 && TYPE_TRANSPARENT_AGGR (node
))
632 fputs (" transparent-aggr", file
);
633 else if (code
== ARRAY_TYPE
634 && TYPE_NONALIASED_COMPONENT (node
))
635 fputs (" nonaliased-component", file
);
637 if (TYPE_PACKED (node
))
638 fputs (" packed", file
);
640 if (TYPE_RESTRICT (node
))
641 fputs (" restrict", file
);
643 if (TYPE_LANG_FLAG_0 (node
))
644 fputs (" type_0", file
);
645 if (TYPE_LANG_FLAG_1 (node
))
646 fputs (" type_1", file
);
647 if (TYPE_LANG_FLAG_2 (node
))
648 fputs (" type_2", file
);
649 if (TYPE_LANG_FLAG_3 (node
))
650 fputs (" type_3", file
);
651 if (TYPE_LANG_FLAG_4 (node
))
652 fputs (" type_4", file
);
653 if (TYPE_LANG_FLAG_5 (node
))
654 fputs (" type_5", file
);
655 if (TYPE_LANG_FLAG_6 (node
))
656 fputs (" type_6", file
);
657 if (TYPE_LANG_FLAG_7 (node
))
658 fputs (" type_7", file
);
660 mode
= TYPE_MODE (node
);
661 fprintf (file
, " %s", GET_MODE_NAME (mode
));
663 print_node (file
, "size", TYPE_SIZE (node
), indent
+ 4);
664 print_node (file
, "unit-size", TYPE_SIZE_UNIT (node
), indent
+ 4);
665 indent_to (file
, indent
+ 3);
667 if (TYPE_USER_ALIGN (node
))
668 fprintf (file
, " user");
670 fprintf (file
, " align:%d warn_if_not_align:%d symtab:%d alias-set "
671 HOST_WIDE_INT_PRINT_DEC
,
672 TYPE_ALIGN (node
), TYPE_WARN_IF_NOT_ALIGN (node
),
673 TYPE_SYMTAB_ADDRESS (node
),
674 (HOST_WIDE_INT
) TYPE_ALIAS_SET (node
));
676 if (TYPE_STRUCTURAL_EQUALITY_P (node
))
677 fprintf (file
, " structural-equality");
679 dump_addr (file
, " canonical-type ", TYPE_CANONICAL (node
));
681 print_node (file
, "attributes", TYPE_ATTRIBUTES (node
), indent
+ 4);
683 if (INTEGRAL_TYPE_P (node
) || code
== REAL_TYPE
684 || code
== FIXED_POINT_TYPE
)
686 fprintf (file
, " precision:%d", TYPE_PRECISION (node
));
687 print_node_brief (file
, "min", TYPE_MIN_VALUE (node
), indent
+ 4);
688 print_node_brief (file
, "max", TYPE_MAX_VALUE (node
), indent
+ 4);
691 if (code
== ENUMERAL_TYPE
)
692 print_node (file
, "values", TYPE_VALUES (node
), indent
+ 4);
693 else if (code
== ARRAY_TYPE
)
694 print_node (file
, "domain", TYPE_DOMAIN (node
), indent
+ 4);
695 else if (code
== VECTOR_TYPE
)
697 fprintf (file
, " nunits:");
698 print_dec (TYPE_VECTOR_SUBPARTS (node
), file
);
700 else if (code
== RECORD_TYPE
701 || code
== UNION_TYPE
702 || code
== QUAL_UNION_TYPE
)
703 print_node (file
, "fields", TYPE_FIELDS (node
), indent
+ 4);
704 else if (code
== FUNCTION_TYPE
705 || code
== METHOD_TYPE
)
707 if (TYPE_METHOD_BASETYPE (node
))
708 print_node_brief (file
, "method basetype",
709 TYPE_METHOD_BASETYPE (node
), indent
+ 4);
710 print_node (file
, "arg-types", TYPE_ARG_TYPES (node
), indent
+ 4);
712 else if (code
== OFFSET_TYPE
)
713 print_node_brief (file
, "basetype", TYPE_OFFSET_BASETYPE (node
),
716 if (TYPE_CONTEXT (node
))
717 print_node_brief (file
, "context", TYPE_CONTEXT (node
), indent
+ 4);
719 lang_hooks
.print_type (file
, node
, indent
);
721 if (TYPE_POINTER_TO (node
) || TREE_CHAIN (node
))
722 indent_to (file
, indent
+ 3);
724 print_node_brief (file
, "pointer_to_this", TYPE_POINTER_TO (node
),
726 print_node_brief (file
, "reference_to_this", TYPE_REFERENCE_TO (node
),
728 print_node_brief (file
, "chain", TREE_CHAIN (node
), indent
+ 4);
738 if (code
== BIND_EXPR
)
740 print_node (file
, "vars", TREE_OPERAND (node
, 0), indent
+ 4);
741 print_node (file
, "body", TREE_OPERAND (node
, 1), indent
+ 4);
742 print_node (file
, "block", TREE_OPERAND (node
, 2), indent
+ 4);
745 if (code
== CALL_EXPR
)
747 print_node (file
, "fn", CALL_EXPR_FN (node
), indent
+ 4);
748 print_node (file
, "static_chain", CALL_EXPR_STATIC_CHAIN (node
),
751 call_expr_arg_iterator iter
;
752 init_call_expr_arg_iterator (node
, &iter
);
753 while (more_call_expr_args_p (&iter
))
755 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
758 sprintf (temp
, "arg:%u", iter
.i
);
759 tree arg
= next_call_expr_arg (&iter
);
761 print_node (file
, temp
, arg
, indent
+ 4);
764 indent_to (file
, indent
+ 4);
765 fprintf (file
, "%s NULL", temp
);
771 len
= TREE_OPERAND_LENGTH (node
);
773 for (i
= 0; i
< len
; i
++)
775 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
779 sprintf (temp
, "arg:%d", i
);
780 print_node (file
, temp
, TREE_OPERAND (node
, i
), indent
+ 4);
783 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
784 print_node (file
, "chain", TREE_CHAIN (node
), indent
+ 4);
788 case tcc_exceptional
:
792 if (TREE_OVERFLOW (node
))
793 fprintf (file
, " overflow");
796 print_dec (wi::to_wide (node
), file
, TYPE_SIGN (TREE_TYPE (node
)));
800 print_real_cst (file
, node
, false);
808 if (TREE_OVERFLOW (node
))
809 fprintf (file
, " overflow");
811 f
= TREE_FIXED_CST (node
);
812 fixed_to_decimal (string
, &f
, sizeof (string
));
813 fprintf (file
, " %s", string
);
819 /* Big enough for UINT_MAX plus the string below. */
822 fprintf (file
, " npatterns:%u nelts-per-pattern:%u",
823 VECTOR_CST_NPATTERNS (node
),
824 VECTOR_CST_NELTS_PER_PATTERN (node
));
825 unsigned int count
= vector_cst_encoded_nelts (node
);
826 for (unsigned int i
= 0; i
< count
; ++i
)
828 sprintf (buf
, "elt:%u: ", i
);
829 print_node (file
, buf
, VECTOR_CST_ENCODED_ELT (node
, i
),
836 print_node (file
, "real", TREE_REALPART (node
), indent
+ 4);
837 print_node (file
, "imag", TREE_IMAGPART (node
), indent
+ 4);
842 const char *p
= TREE_STRING_POINTER (node
);
843 int i
= TREE_STRING_LENGTH (node
);
848 if (ch
>= ' ' && ch
< 127)
851 fprintf (file
, "\\%03o", ch
& 0xFF);
860 for (unsigned int i
= 0; i
< NUM_POLY_INT_COEFFS
; ++i
)
862 snprintf (buf
, sizeof (buf
), "elt%u:", i
);
863 print_node (file
, buf
, POLY_INT_CST_COEFF (node
, i
),
869 case IDENTIFIER_NODE
:
870 lang_hooks
.print_identifier (file
, node
, indent
);
874 print_node (file
, "purpose", TREE_PURPOSE (node
), indent
+ 4);
875 print_node (file
, "value", TREE_VALUE (node
), indent
+ 4);
876 print_node (file
, "chain", TREE_CHAIN (node
), indent
+ 4);
880 len
= TREE_VEC_LENGTH (node
);
881 fprintf (file
, " length:%d", len
);
882 for (i
= 0; i
< len
; i
++)
883 if (TREE_VEC_ELT (node
, i
))
885 /* Buffer big enough to format a 32-bit UINT_MAX into, plus
888 sprintf (temp
, "elt:%d", i
);
889 print_node (file
, temp
, TREE_VEC_ELT (node
, i
), indent
+ 4);
895 unsigned HOST_WIDE_INT cnt
;
897 len
= CONSTRUCTOR_NELTS (node
);
898 fprintf (file
, " length:%d", len
);
899 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node
),
902 print_node (file
, "idx", index
, indent
+ 4, false);
903 print_node (file
, "val", value
, indent
+ 4, false);
909 dump_addr (file
, " head ", node
->stmt_list
.head
);
910 dump_addr (file
, " tail ", node
->stmt_list
.tail
);
911 fprintf (file
, " stmts");
913 tree_stmt_iterator i
;
914 for (i
= tsi_start (node
); !tsi_end_p (i
); tsi_next (&i
))
916 /* Not printing the addresses of the (not-a-tree)
917 'struct tree_stmt_list_node's. */
918 dump_addr (file
, " ", tsi_stmt (i
));
920 fprintf (file
, "\n");
921 for (i
= tsi_start (node
); !tsi_end_p (i
); tsi_next (&i
))
923 /* Not printing the addresses of the (not-a-tree)
924 'struct tree_stmt_list_node's. */
925 print_node (file
, "stmt", tsi_stmt (i
), indent
+ 4);
931 print_node (file
, "vars", BLOCK_VARS (node
), indent
+ 4);
932 print_node (file
, "supercontext", BLOCK_SUPERCONTEXT (node
),
934 print_node (file
, "subblocks", BLOCK_SUBBLOCKS (node
), indent
+ 4);
935 print_node (file
, "chain", BLOCK_CHAIN (node
), indent
+ 4);
936 print_node (file
, "abstract_origin",
937 BLOCK_ABSTRACT_ORIGIN (node
), indent
+ 4);
941 print_node_brief (file
, "var", SSA_NAME_VAR (node
), indent
+ 4);
942 indent_to (file
, indent
+ 4);
943 fprintf (file
, "def_stmt ");
945 pretty_printer buffer
;
946 buffer
.buffer
->stream
= file
;
947 pp_gimple_stmt_1 (&buffer
, SSA_NAME_DEF_STMT (node
), indent
+ 4,
952 indent_to (file
, indent
+ 4);
953 fprintf (file
, "version:%u", SSA_NAME_VERSION (node
));
954 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node
))
955 fprintf (file
, " in-abnormal-phi");
956 if (SSA_NAME_IN_FREE_LIST (node
))
957 fprintf (file
, " in-free-list");
959 if (SSA_NAME_PTR_INFO (node
))
961 indent_to (file
, indent
+ 3);
962 if (SSA_NAME_PTR_INFO (node
))
963 dump_addr (file
, " ptr-info ", SSA_NAME_PTR_INFO (node
));
970 fprintf (file
, " %s",
971 omp_clause_code_name
[OMP_CLAUSE_CODE (node
)]);
972 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (node
)]; i
++)
974 indent_to (file
, indent
+ 4);
975 fprintf (file
, "op-%d:", i
);
976 print_node_brief (file
, "", OMP_CLAUSE_OPERAND (node
, i
), 0);
981 case OPTIMIZATION_NODE
:
982 cl_optimization_print (file
, indent
+ 4, TREE_OPTIMIZATION (node
));
985 case TARGET_OPTION_NODE
:
986 cl_target_option_print (file
, indent
+ 4, TREE_TARGET_OPTION (node
));
989 fprintf (file
, " imported-declaration");
990 print_node_brief (file
, "associated-declaration",
991 IMPORTED_DECL_ASSOCIATED_DECL (node
),
996 fprintf (file
, " bases:%d",
997 vec_safe_length (BINFO_BASE_BINFOS (node
)));
998 print_node_brief (file
, "offset", BINFO_OFFSET (node
), indent
+ 4);
999 print_node_brief (file
, "virtuals", BINFO_VIRTUALS (node
),
1001 print_node_brief (file
, "inheritance-chain",
1002 BINFO_INHERITANCE_CHAIN (node
),
1007 lang_hooks
.print_xnode (file
, node
, indent
);
1014 if (EXPR_HAS_LOCATION (node
))
1016 expanded_location xloc
= expand_location (EXPR_LOCATION (node
));
1017 indent_to (file
, indent
+4);
1018 fprintf (file
, "%s:%d:%d", xloc
.file
, xloc
.line
, xloc
.column
);
1020 /* Print the range, if any */
1021 source_range r
= EXPR_LOCATION_RANGE (node
);
1024 xloc
= expand_location (r
.m_start
);
1025 fprintf (file
, " start: %s:%d:%d", xloc
.file
, xloc
.line
, xloc
.column
);
1029 fprintf (file
, " start: unknown");
1033 xloc
= expand_location (r
.m_finish
);
1034 fprintf (file
, " finish: %s:%d:%d", xloc
.file
, xloc
.line
, xloc
.column
);
1038 fprintf (file
, " finish: unknown");
1042 fprintf (file
, ">");
1045 /* Print the identifier for DECL according to FLAGS. */
1048 print_decl_identifier (FILE *file
, tree decl
, int flags
)
1050 bool needs_colon
= false;
1054 if (flags
& PRINT_DECL_ORIGIN
)
1056 if (DECL_IS_UNDECLARED_BUILTIN (decl
))
1057 fputs ("<built-in>", file
);
1060 expanded_location loc
1061 = expand_location (DECL_SOURCE_LOCATION (decl
));
1062 fprintf (file
, "%s:%d:%d", loc
.file
, loc
.line
, loc
.column
);
1067 if (flags
& PRINT_DECL_UNIQUE_NAME
)
1069 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1070 if (!TREE_PUBLIC (decl
)
1071 || (DECL_WEAK (decl
) && !DECL_EXTERNAL (decl
)))
1072 /* The symbol has internal or weak linkage so its assembler name
1073 is not necessarily unique among the compilation units of the
1074 program. We therefore have to further mangle it. But we can't
1075 simply use DECL_SOURCE_FILE because it contains the name of the
1076 file the symbol originates from so, e.g. for function templates
1077 in C++ where the templates are defined in a header file, we can
1078 have symbols with the same assembler name and DECL_SOURCE_FILE.
1079 That's why we use the name of the top-level source file of the
1080 compilation unit. ??? Unnecessary for Ada. */
1081 name
= ACONCAT ((main_input_filename
, ":", name
, NULL
));
1083 else if (flags
& PRINT_DECL_NAME
)
1085 /* We don't want to print the full qualified name because it can be long,
1086 so we strip the scope prefix, but we may need to deal with the suffix
1087 created by the compiler. */
1088 const char *suffix
= strchr (IDENTIFIER_POINTER (DECL_NAME (decl
)), '.');
1089 name
= lang_hooks
.decl_printable_name (decl
, 2);
1092 const char *dot
= strchr (name
, '.');
1093 while (dot
&& strcasecmp (dot
, suffix
) != 0)
1096 dot
= strchr (name
, '.');
1101 const char *dot
= strrchr (name
, '.');
1112 while ((c
= *name
++) != '\0')
1114 /* Strip double-quotes because of VCG. */
1122 /* Print the node NODE on standard error, for debugging.
1123 Most nodes referred to by this one are printed recursively
1124 down to a depth of six. */
1127 debug_tree (tree node
)
1129 table
= new hash_set
<tree
> (HASH_SIZE
);
1130 print_node (stderr
, "", node
, 0);
1133 putc ('\n', stderr
);
1137 debug_raw (const tree_node
&ref
)
1139 debug_tree (const_cast <tree
> (&ref
));
1143 debug_raw (const tree_node
*ptr
)
1148 fprintf (stderr
, "<nil>\n");
1152 dump_tree_via_hooks (const tree_node
*ptr
, dump_flags_t options
)
1155 lang_hooks
.print_decl (stderr
, const_cast <tree_node
*> (ptr
), 0);
1156 else if (TYPE_P (ptr
))
1157 lang_hooks
.print_type (stderr
, const_cast <tree_node
*> (ptr
), 0);
1158 else if (TREE_CODE (ptr
) == IDENTIFIER_NODE
)
1159 lang_hooks
.print_identifier (stderr
, const_cast <tree_node
*> (ptr
), 0);
1161 print_generic_expr (stderr
, const_cast <tree_node
*> (ptr
), options
);
1162 fprintf (stderr
, "\n");
1166 debug (const tree_node
&ref
)
1168 dump_tree_via_hooks (&ref
, TDF_NONE
);
1172 debug (const tree_node
*ptr
)
1177 fprintf (stderr
, "<nil>\n");
1181 debug_head (const tree_node
&ref
)
1187 debug_head (const tree_node
*ptr
)
1192 fprintf (stderr
, "<nil>\n");
1196 debug_body (const tree_node
&ref
)
1198 if (TREE_CODE (&ref
) == FUNCTION_DECL
)
1199 dump_function_to_file (const_cast <tree_node
*> (&ref
), stderr
, TDF_NONE
);
1205 debug_body (const tree_node
*ptr
)
1210 fprintf (stderr
, "<nil>\n");
1213 /* Print the vector of trees VEC on standard error, for debugging.
1214 Most nodes referred to by this one are printed recursively
1215 down to a depth of six. */
1218 debug_raw (vec
<tree
, va_gc
> &ref
)
1223 /* Print the slot this node is in, and its code, and address. */
1224 fprintf (stderr
, "<VEC");
1225 dump_addr (stderr
, " ", ref
.address ());
1227 FOR_EACH_VEC_ELT (ref
, ix
, elt
)
1229 fprintf (stderr
, "elt:%d ", ix
);
1235 debug_raw (vec
<tree
, va_gc
> *ptr
)
1240 fprintf (stderr
, "<nil>\n");
1246 print_node_brief (stderr
, "", t
, 0);
1249 DEFINE_DEBUG_VEC (tree
)
1250 DEFINE_DEBUG_HASH_SET (tree
)