1 /* Tree-dumping functionality for intermediate representation.
2 Copyright (C) 1999-2017 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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/>. */
23 #include "coretypes.h"
25 #include "tree-pretty-print.h"
26 #include "tree-dump.h"
27 #include "langhooks.h"
28 #include "tree-iterator.h"
31 static unsigned int queue (dump_info_p
, const_tree
, int);
32 static void dump_index (dump_info_p
, unsigned int);
33 static void dequeue_and_dump (dump_info_p
);
34 static void dump_new_line (dump_info_p
);
35 static void dump_maybe_newline (dump_info_p
);
37 /* Add T to the end of the queue of nodes to dump. Returns the index
41 queue (dump_info_p di
, const_tree t
, int flags
)
47 /* Assign the next available index to T. */
50 /* Obtain a new queue node. */
54 di
->free_list
= dq
->next
;
57 dq
= XNEW (struct dump_queue
);
59 /* Create a new entry in the splay-tree. */
60 dni
= XNEW (struct dump_node_info
);
62 dni
->binfo_p
= ((flags
& DUMP_BINFO
) != 0);
63 dq
->node
= splay_tree_insert (di
->nodes
, (splay_tree_key
) t
,
64 (splay_tree_value
) dni
);
66 /* Add it to the end of the queue. */
71 di
->queue_end
->next
= dq
;
74 /* Return the index. */
79 dump_index (dump_info_p di
, unsigned int index
)
81 fprintf (di
->stream
, "@%-6u ", index
);
85 /* If T has not already been output, queue it for subsequent output.
86 FIELD is a string to print before printing the index. Then, the
87 index of T is printed. */
90 queue_and_dump_index (dump_info_p di
, const char *field
, const_tree t
, int flags
)
95 /* If there's no node, just return. This makes for fewer checks in
100 /* See if we've already queued or dumped this node. */
101 n
= splay_tree_lookup (di
->nodes
, (splay_tree_key
) t
);
103 index
= ((dump_node_info_p
) n
->value
)->index
;
105 /* If we haven't, add it to the queue. */
106 index
= queue (di
, t
, flags
);
108 /* Print the index of the node. */
109 dump_maybe_newline (di
);
110 fprintf (di
->stream
, "%-4s: ", field
);
112 dump_index (di
, index
);
115 /* Dump the type of T. */
118 queue_and_dump_type (dump_info_p di
, const_tree t
)
120 queue_and_dump_index (di
, "type", TREE_TYPE (t
), DUMP_NONE
);
123 /* Dump column control */
124 #define SOL_COLUMN 25 /* Start of line column. */
125 #define EOL_COLUMN 55 /* End of line column. */
126 #define COLUMN_ALIGNMENT 15 /* Alignment. */
128 /* Insert a new line in the dump output, and indent to an appropriate
129 place to start printing more fields. */
132 dump_new_line (dump_info_p di
)
134 fprintf (di
->stream
, "\n%*s", SOL_COLUMN
, "");
135 di
->column
= SOL_COLUMN
;
138 /* If necessary, insert a new line. */
141 dump_maybe_newline (dump_info_p di
)
145 /* See if we need a new line. */
146 if (di
->column
> EOL_COLUMN
)
148 /* See if we need any padding. */
149 else if ((extra
= (di
->column
- SOL_COLUMN
) % COLUMN_ALIGNMENT
) != 0)
151 fprintf (di
->stream
, "%*s", COLUMN_ALIGNMENT
- extra
, "");
152 di
->column
+= COLUMN_ALIGNMENT
- extra
;
156 /* Dump pointer PTR using FIELD to identify it. */
159 dump_pointer (dump_info_p di
, const char *field
, void *ptr
)
161 dump_maybe_newline (di
);
162 fprintf (di
->stream
, "%-4s: %-8" HOST_WIDE_INT_PRINT
"x ", field
,
163 (unsigned HOST_WIDE_INT
) (uintptr_t) ptr
);
167 /* Dump integer I using FIELD to identify it. */
170 dump_int (dump_info_p di
, const char *field
, int i
)
172 dump_maybe_newline (di
);
173 fprintf (di
->stream
, "%-4s: %-7d ", field
, i
);
177 /* Dump the floating point value R, using FIELD to identify it. */
180 dump_real (dump_info_p di
, const char *field
, const REAL_VALUE_TYPE
*r
)
183 real_to_decimal (buf
, r
, sizeof (buf
), 0, true);
184 dump_maybe_newline (di
);
185 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
186 di
->column
+= strlen (buf
) + 7;
189 /* Dump the fixed-point value F, using FIELD to identify it. */
192 dump_fixed (dump_info_p di
, const char *field
, const FIXED_VALUE_TYPE
*f
)
195 fixed_to_decimal (buf
, f
, sizeof (buf
));
196 dump_maybe_newline (di
);
197 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
198 di
->column
+= strlen (buf
) + 7;
202 /* Dump the string S. */
205 dump_string (dump_info_p di
, const char *string
)
207 dump_maybe_newline (di
);
208 fprintf (di
->stream
, "%-13s ", string
);
209 if (strlen (string
) > 13)
210 di
->column
+= strlen (string
) + 1;
215 /* Dump the string field S. */
218 dump_string_field (dump_info_p di
, const char *field
, const char *string
)
220 dump_maybe_newline (di
);
221 fprintf (di
->stream
, "%-4s: %-7s ", field
, string
);
222 if (strlen (string
) > 7)
223 di
->column
+= 6 + strlen (string
) + 1;
228 /* Dump the next node in the queue. */
231 dequeue_and_dump (dump_info_p di
)
235 dump_node_info_p dni
;
239 enum tree_code_class code_class
;
240 const char* code_name
;
242 /* Get the next node from the queue. */
246 dni
= (dump_node_info_p
) stn
->value
;
249 /* Remove the node from the queue, and put it on the free list. */
250 di
->queue
= dq
->next
;
253 dq
->next
= di
->free_list
;
256 /* Print the node index. */
257 dump_index (di
, index
);
258 /* And the type of node this is. */
262 code_name
= get_tree_code_name (TREE_CODE (t
));
263 fprintf (di
->stream
, "%-16s ", code_name
);
266 /* Figure out what kind of node this is. */
267 code
= TREE_CODE (t
);
268 code_class
= TREE_CODE_CLASS (code
);
270 /* Although BINFOs are TREE_VECs, we dump them specially so as to be
276 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (t
);
278 dump_child ("type", BINFO_TYPE (t
));
280 if (BINFO_VIRTUAL_P (t
))
281 dump_string_field (di
, "spec", "virt");
283 dump_int (di
, "bases", BINFO_N_BASE_BINFOS (t
));
284 for (ix
= 0; BINFO_BASE_ITERATE (t
, ix
, base
); ix
++)
286 tree access
= (accesses
? (*accesses
)[ix
] : access_public_node
);
287 const char *string
= NULL
;
289 if (access
== access_public_node
)
291 else if (access
== access_protected_node
)
293 else if (access
== access_private_node
)
298 dump_string_field (di
, "accs", string
);
299 queue_and_dump_index (di
, "binf", base
, DUMP_BINFO
);
305 /* We can knock off a bunch of expression nodes in exactly the same
307 if (IS_EXPR_CODE_CLASS (code_class
))
309 /* If we're dumping children, dump them now. */
310 queue_and_dump_type (di
, t
);
315 dump_child ("op 0", TREE_OPERAND (t
, 0));
320 dump_child ("op 0", TREE_OPERAND (t
, 0));
321 dump_child ("op 1", TREE_OPERAND (t
, 1));
328 /* These nodes are handled explicitly below. */
337 expanded_location xloc
;
338 /* All declarations have names. */
340 dump_child ("name", DECL_NAME (t
));
341 if (DECL_ASSEMBLER_NAME_SET_P (t
)
342 && DECL_ASSEMBLER_NAME (t
) != DECL_NAME (t
))
343 dump_child ("mngl", DECL_ASSEMBLER_NAME (t
));
344 if (DECL_ABSTRACT_ORIGIN (t
))
345 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t
));
347 queue_and_dump_type (di
, t
);
348 dump_child ("scpe", DECL_CONTEXT (t
));
349 /* And a source position. */
350 xloc
= expand_location (DECL_SOURCE_LOCATION (t
));
353 const char *filename
= lbasename (xloc
.file
);
355 dump_maybe_newline (di
);
356 fprintf (di
->stream
, "srcp: %s:%-6d ", filename
,
358 di
->column
+= 6 + strlen (filename
) + 8;
360 /* And any declaration can be compiler-generated. */
361 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_COMMON
)
362 && DECL_ARTIFICIAL (t
))
363 dump_string_field (di
, "note", "artificial");
364 if (DECL_CHAIN (t
) && !dump_flag (di
, TDF_SLIM
, NULL
))
365 dump_child ("chain", DECL_CHAIN (t
));
367 else if (code_class
== tcc_type
)
369 /* All types have qualifiers. */
370 int quals
= lang_hooks
.tree_dump
.type_quals (t
);
372 if (quals
!= TYPE_UNQUALIFIED
)
374 fprintf (di
->stream
, "qual: %c%c%c ",
375 (quals
& TYPE_QUAL_CONST
) ? 'c' : ' ',
376 (quals
& TYPE_QUAL_VOLATILE
) ? 'v' : ' ',
377 (quals
& TYPE_QUAL_RESTRICT
) ? 'r' : ' ');
381 /* All types have associated declarations. */
382 dump_child ("name", TYPE_NAME (t
));
384 /* All types have a main variant. */
385 if (TYPE_MAIN_VARIANT (t
) != t
)
386 dump_child ("unql", TYPE_MAIN_VARIANT (t
));
389 dump_child ("size", TYPE_SIZE (t
));
391 /* All types have alignments. */
392 dump_int (di
, "algn", TYPE_ALIGN (t
));
394 else if (code_class
== tcc_constant
)
395 /* All constants can have types. */
396 queue_and_dump_type (di
, t
);
398 /* Give the language-specific code a chance to print something. If
399 it's completely taken care of things, don't bother printing
400 anything more ourselves. */
401 if (lang_hooks
.tree_dump
.dump_tree (di
, t
))
404 /* Now handle the various kinds of nodes. */
409 case IDENTIFIER_NODE
:
410 dump_string_field (di
, "strg", IDENTIFIER_POINTER (t
));
411 dump_int (di
, "lngt", IDENTIFIER_LENGTH (t
));
415 dump_child ("purp", TREE_PURPOSE (t
));
416 dump_child ("valu", TREE_VALUE (t
));
417 dump_child ("chan", TREE_CHAIN (t
));
422 tree_stmt_iterator it
;
423 for (i
= 0, it
= tsi_start (t
); !tsi_end_p (it
); tsi_next (&it
), i
++)
426 sprintf (buffer
, "%u", i
);
427 dump_child (buffer
, tsi_stmt (it
));
433 dump_int (di
, "lngt", TREE_VEC_LENGTH (t
));
434 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
437 sprintf (buffer
, "%u", i
);
438 dump_child (buffer
, TREE_VEC_ELT (t
, i
));
444 dump_int (di
, "prec", TYPE_PRECISION (t
));
445 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
446 dump_child ("min", TYPE_MIN_VALUE (t
));
447 dump_child ("max", TYPE_MAX_VALUE (t
));
449 if (code
== ENUMERAL_TYPE
)
450 dump_child ("csts", TYPE_VALUES (t
));
454 dump_int (di
, "prec", TYPE_PRECISION (t
));
457 case FIXED_POINT_TYPE
:
458 dump_int (di
, "prec", TYPE_PRECISION (t
));
459 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
460 dump_string_field (di
, "saturating",
461 TYPE_SATURATING (t
) ? "saturating": "non-saturating");
465 dump_child ("ptd", TREE_TYPE (t
));
469 dump_child ("refd", TREE_TYPE (t
));
473 dump_child ("clas", TYPE_METHOD_BASETYPE (t
));
477 dump_child ("retn", TREE_TYPE (t
));
478 dump_child ("prms", TYPE_ARG_TYPES (t
));
482 dump_child ("elts", TREE_TYPE (t
));
483 dump_child ("domn", TYPE_DOMAIN (t
));
488 if (TREE_CODE (t
) == RECORD_TYPE
)
489 dump_string_field (di
, "tag", "struct");
491 dump_string_field (di
, "tag", "union");
493 dump_child ("flds", TYPE_FIELDS (t
));
494 dump_child ("fncs", TYPE_METHODS (t
));
495 queue_and_dump_index (di
, "binf", TYPE_BINFO (t
),
500 dump_child ("cnst", DECL_INITIAL (t
));
503 case DEBUG_EXPR_DECL
:
504 dump_int (di
, "-uid", DEBUG_TEMP_UID (t
));
511 if (TREE_CODE (t
) == PARM_DECL
)
512 dump_child ("argt", DECL_ARG_TYPE (t
));
514 dump_child ("init", DECL_INITIAL (t
));
515 dump_child ("size", DECL_SIZE (t
));
516 dump_int (di
, "algn", DECL_ALIGN (t
));
518 if (TREE_CODE (t
) == FIELD_DECL
)
520 if (DECL_FIELD_OFFSET (t
))
521 dump_child ("bpos", bit_position (t
));
523 else if (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
525 dump_int (di
, "used", TREE_USED (t
));
526 if (DECL_REGISTER (t
))
527 dump_string_field (di
, "spec", "register");
532 dump_child ("args", DECL_ARGUMENTS (t
));
533 if (DECL_EXTERNAL (t
))
534 dump_string_field (di
, "body", "undefined");
536 dump_string_field (di
, "link", "extern");
538 dump_string_field (di
, "link", "static");
539 if (DECL_SAVED_TREE (t
) && !dump_flag (di
, TDF_SLIM
, t
))
540 dump_child ("body", DECL_SAVED_TREE (t
));
544 fprintf (di
->stream
, "int: ");
545 print_decs (t
, di
->stream
);
549 fprintf (di
->stream
, "strg: %-7s ", TREE_STRING_POINTER (t
));
550 dump_int (di
, "lngt", TREE_STRING_LENGTH (t
));
554 dump_real (di
, "valu", TREE_REAL_CST_PTR (t
));
558 dump_fixed (di
, "valu", TREE_FIXED_CST_PTR (t
));
564 case CLEANUP_POINT_EXPR
:
568 /* These nodes are unary, but do not have code class `1'. */
569 dump_child ("op 0", TREE_OPERAND (t
, 0));
572 case TRUTH_ANDIF_EXPR
:
573 case TRUTH_ORIF_EXPR
:
577 case PREDECREMENT_EXPR
:
578 case PREINCREMENT_EXPR
:
579 case POSTDECREMENT_EXPR
:
580 case POSTINCREMENT_EXPR
:
581 /* These nodes are binary, but do not have code class `2'. */
582 dump_child ("op 0", TREE_OPERAND (t
, 0));
583 dump_child ("op 1", TREE_OPERAND (t
, 1));
588 dump_child ("op 0", TREE_OPERAND (t
, 0));
589 dump_child ("op 1", TREE_OPERAND (t
, 1));
590 dump_child ("op 2", TREE_OPERAND (t
, 2));
594 case ARRAY_RANGE_REF
:
595 dump_child ("op 0", TREE_OPERAND (t
, 0));
596 dump_child ("op 1", TREE_OPERAND (t
, 1));
597 dump_child ("op 2", TREE_OPERAND (t
, 2));
598 dump_child ("op 3", TREE_OPERAND (t
, 3));
602 dump_child ("op 0", TREE_OPERAND (t
, 0));
603 dump_child ("op 1", TREE_OPERAND (t
, 1));
604 dump_child ("op 2", TREE_OPERAND (t
, 2));
607 case TRY_FINALLY_EXPR
:
608 dump_child ("op 0", TREE_OPERAND (t
, 0));
609 dump_child ("op 1", TREE_OPERAND (t
, 1));
616 call_expr_arg_iterator iter
;
617 dump_child ("fn", CALL_EXPR_FN (t
));
618 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
621 sprintf (buffer
, "%u", i
);
622 dump_child (buffer
, arg
);
630 unsigned HOST_WIDE_INT cnt
;
632 dump_int (di
, "lngt", CONSTRUCTOR_NELTS (t
));
633 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), cnt
, index
, value
)
635 dump_child ("idx", index
);
636 dump_child ("val", value
);
642 dump_child ("vars", TREE_OPERAND (t
, 0));
643 dump_child ("body", TREE_OPERAND (t
, 1));
647 dump_child ("body", TREE_OPERAND (t
, 0));
651 dump_child ("cond", TREE_OPERAND (t
, 0));
655 dump_child ("expr", TREE_OPERAND (t
, 0));
659 dump_child ("decl", TREE_OPERAND (t
, 0));
660 dump_child ("init", TREE_OPERAND (t
, 1));
661 dump_child ("clnp", TREE_OPERAND (t
, 2));
662 /* There really are two possible places the initializer can be.
663 After RTL expansion, the second operand is moved to the
664 position of the fourth operand, and the second operand
666 dump_child ("init", TREE_OPERAND (t
, 3));
669 case CASE_LABEL_EXPR
:
670 dump_child ("name", CASE_LABEL (t
));
673 dump_child ("low ", CASE_LOW (t
));
675 dump_child ("high", CASE_HIGH (t
));
679 dump_child ("name", TREE_OPERAND (t
,0));
682 dump_child ("labl", TREE_OPERAND (t
, 0));
685 dump_child ("cond", TREE_OPERAND (t
, 0));
686 dump_child ("body", TREE_OPERAND (t
, 1));
687 if (TREE_OPERAND (t
, 2))
689 dump_child ("labl", TREE_OPERAND (t
,2));
695 fprintf (di
->stream
, "%s\n", omp_clause_code_name
[OMP_CLAUSE_CODE (t
)]);
696 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
697 dump_child ("op: ", OMP_CLAUSE_OPERAND (t
, i
));
701 /* There are no additional fields to print. */
706 if (dump_flag (di
, TDF_ADDRESS
, NULL
))
707 dump_pointer (di
, "addr", (void *)t
);
709 /* Terminate the line. */
710 fprintf (di
->stream
, "\n");
713 /* Return nonzero if FLAG has been specified for the dump, and NODE
714 is not the root node of the dump. */
716 int dump_flag (dump_info_p di
, dump_flags_t flag
, const_tree node
)
718 return (di
->flags
& flag
) && (node
!= di
->node
);
721 /* Dump T, and all its children, on STREAM. */
724 dump_node (const_tree t
, dump_flags_t flags
, FILE *stream
)
728 dump_queue_p next_dq
;
730 /* Initialize the dump-information structure. */
739 di
.nodes
= splay_tree_new (splay_tree_compare_pointers
, 0,
740 (splay_tree_delete_value_fn
) &free
);
742 /* Queue up the first node. */
743 queue (&di
, t
, DUMP_NONE
);
745 /* Until the queue is empty, keep dumping nodes. */
747 dequeue_and_dump (&di
);
750 for (dq
= di
.free_list
; dq
; dq
= next_dq
)
755 splay_tree_delete (di
.nodes
);