1 /* Tree-dumping functionality for intermediate representation.
2 Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010, 2011, 2012 Free Software Foundation, Inc.
4 Written by Mark Mitchell <mark@codesourcery.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
27 #include "splay-tree.h"
28 #include "filenames.h"
29 #include "tree-dump.h"
30 #include "langhooks.h"
31 #include "tree-iterator.h"
33 static unsigned int queue (dump_info_p
, const_tree
, int);
34 static void dump_index (dump_info_p
, unsigned int);
35 static void dequeue_and_dump (dump_info_p
);
36 static void dump_new_line (dump_info_p
);
37 static void dump_maybe_newline (dump_info_p
);
39 /* Add T to the end of the queue of nodes to dump. Returns the index
43 queue (dump_info_p di
, const_tree t
, int flags
)
49 /* Assign the next available index to T. */
52 /* Obtain a new queue node. */
56 di
->free_list
= dq
->next
;
59 dq
= XNEW (struct dump_queue
);
61 /* Create a new entry in the splay-tree. */
62 dni
= XNEW (struct dump_node_info
);
64 dni
->binfo_p
= ((flags
& DUMP_BINFO
) != 0);
65 dq
->node
= splay_tree_insert (di
->nodes
, (splay_tree_key
) t
,
66 (splay_tree_value
) dni
);
68 /* Add it to the end of the queue. */
73 di
->queue_end
->next
= dq
;
76 /* Return the index. */
81 dump_index (dump_info_p di
, unsigned int index
)
83 fprintf (di
->stream
, "@%-6u ", index
);
87 /* If T has not already been output, queue it for subsequent output.
88 FIELD is a string to print before printing the index. Then, the
89 index of T is printed. */
92 queue_and_dump_index (dump_info_p di
, const char *field
, const_tree t
, int flags
)
97 /* If there's no node, just return. This makes for fewer checks in
102 /* See if we've already queued or dumped this node. */
103 n
= splay_tree_lookup (di
->nodes
, (splay_tree_key
) t
);
105 index
= ((dump_node_info_p
) n
->value
)->index
;
107 /* If we haven't, add it to the queue. */
108 index
= queue (di
, t
, flags
);
110 /* Print the index of the node. */
111 dump_maybe_newline (di
);
112 fprintf (di
->stream
, "%-4s: ", field
);
114 dump_index (di
, index
);
117 /* Dump the type of T. */
120 queue_and_dump_type (dump_info_p di
, const_tree t
)
122 queue_and_dump_index (di
, "type", TREE_TYPE (t
), DUMP_NONE
);
125 /* Dump column control */
126 #define SOL_COLUMN 25 /* Start of line column. */
127 #define EOL_COLUMN 55 /* End of line column. */
128 #define COLUMN_ALIGNMENT 15 /* Alignment. */
130 /* Insert a new line in the dump output, and indent to an appropriate
131 place to start printing more fields. */
134 dump_new_line (dump_info_p di
)
136 fprintf (di
->stream
, "\n%*s", SOL_COLUMN
, "");
137 di
->column
= SOL_COLUMN
;
140 /* If necessary, insert a new line. */
143 dump_maybe_newline (dump_info_p di
)
147 /* See if we need a new line. */
148 if (di
->column
> EOL_COLUMN
)
150 /* See if we need any padding. */
151 else if ((extra
= (di
->column
- SOL_COLUMN
) % COLUMN_ALIGNMENT
) != 0)
153 fprintf (di
->stream
, "%*s", COLUMN_ALIGNMENT
- extra
, "");
154 di
->column
+= COLUMN_ALIGNMENT
- extra
;
158 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
161 dump_function (int phase
, tree fn
)
166 stream
= dump_begin (phase
, &flags
);
169 dump_function_to_file (fn
, stream
, flags
);
170 dump_end (phase
, stream
);
174 /* Dump pointer PTR using FIELD to identify it. */
177 dump_pointer (dump_info_p di
, const char *field
, void *ptr
)
179 dump_maybe_newline (di
);
180 fprintf (di
->stream
, "%-4s: %-8lx ", field
, (unsigned long) ptr
);
184 /* Dump integer I using FIELD to identify it. */
187 dump_int (dump_info_p di
, const char *field
, int i
)
189 dump_maybe_newline (di
);
190 fprintf (di
->stream
, "%-4s: %-7d ", field
, i
);
194 /* Dump the floating point value R, using FIELD to identify it. */
197 dump_real (dump_info_p di
, const char *field
, const REAL_VALUE_TYPE
*r
)
200 real_to_decimal (buf
, r
, sizeof (buf
), 0, true);
201 dump_maybe_newline (di
);
202 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
203 di
->column
+= strlen (buf
) + 7;
206 /* Dump the fixed-point value F, using FIELD to identify it. */
209 dump_fixed (dump_info_p di
, const char *field
, const FIXED_VALUE_TYPE
*f
)
212 fixed_to_decimal (buf
, f
, sizeof (buf
));
213 dump_maybe_newline (di
);
214 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
215 di
->column
+= strlen (buf
) + 7;
219 /* Dump the string S. */
222 dump_string (dump_info_p di
, const char *string
)
224 dump_maybe_newline (di
);
225 fprintf (di
->stream
, "%-13s ", string
);
226 if (strlen (string
) > 13)
227 di
->column
+= strlen (string
) + 1;
232 /* Dump the string field S. */
235 dump_string_field (dump_info_p di
, const char *field
, const char *string
)
237 dump_maybe_newline (di
);
238 fprintf (di
->stream
, "%-4s: %-7s ", field
, string
);
239 if (strlen (string
) > 7)
240 di
->column
+= 6 + strlen (string
) + 1;
245 /* Dump the next node in the queue. */
248 dequeue_and_dump (dump_info_p di
)
252 dump_node_info_p dni
;
256 enum tree_code_class code_class
;
257 const char* code_name
;
259 /* Get the next node from the queue. */
263 dni
= (dump_node_info_p
) stn
->value
;
266 /* Remove the node from the queue, and put it on the free list. */
267 di
->queue
= dq
->next
;
270 dq
->next
= di
->free_list
;
273 /* Print the node index. */
274 dump_index (di
, index
);
275 /* And the type of node this is. */
279 code_name
= tree_code_name
[(int) TREE_CODE (t
)];
280 fprintf (di
->stream
, "%-16s ", code_name
);
283 /* Figure out what kind of node this is. */
284 code
= TREE_CODE (t
);
285 code_class
= TREE_CODE_CLASS (code
);
287 /* Although BINFOs are TREE_VECs, we dump them specially so as to be
293 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (t
);
295 dump_child ("type", BINFO_TYPE (t
));
297 if (BINFO_VIRTUAL_P (t
))
298 dump_string_field (di
, "spec", "virt");
300 dump_int (di
, "bases", BINFO_N_BASE_BINFOS (t
));
301 for (ix
= 0; BINFO_BASE_ITERATE (t
, ix
, base
); ix
++)
303 tree access
= (accesses
? (*accesses
)[ix
] : access_public_node
);
304 const char *string
= NULL
;
306 if (access
== access_public_node
)
308 else if (access
== access_protected_node
)
310 else if (access
== access_private_node
)
315 dump_string_field (di
, "accs", string
);
316 queue_and_dump_index (di
, "binf", base
, DUMP_BINFO
);
322 /* We can knock off a bunch of expression nodes in exactly the same
324 if (IS_EXPR_CODE_CLASS (code_class
))
326 /* If we're dumping children, dump them now. */
327 queue_and_dump_type (di
, t
);
332 dump_child ("op 0", TREE_OPERAND (t
, 0));
337 dump_child ("op 0", TREE_OPERAND (t
, 0));
338 dump_child ("op 1", TREE_OPERAND (t
, 1));
345 /* These nodes are handled explicitly below. */
354 expanded_location xloc
;
355 /* All declarations have names. */
357 dump_child ("name", DECL_NAME (t
));
358 if (DECL_ASSEMBLER_NAME_SET_P (t
)
359 && DECL_ASSEMBLER_NAME (t
) != DECL_NAME (t
))
360 dump_child ("mngl", DECL_ASSEMBLER_NAME (t
));
361 if (DECL_ABSTRACT_ORIGIN (t
))
362 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t
));
364 queue_and_dump_type (di
, t
);
365 dump_child ("scpe", DECL_CONTEXT (t
));
366 /* And a source position. */
367 xloc
= expand_location (DECL_SOURCE_LOCATION (t
));
370 const char *filename
= lbasename (xloc
.file
);
372 dump_maybe_newline (di
);
373 fprintf (di
->stream
, "srcp: %s:%-6d ", filename
,
375 di
->column
+= 6 + strlen (filename
) + 8;
377 /* And any declaration can be compiler-generated. */
378 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_COMMON
)
379 && DECL_ARTIFICIAL (t
))
380 dump_string_field (di
, "note", "artificial");
381 if (DECL_CHAIN (t
) && !dump_flag (di
, TDF_SLIM
, NULL
))
382 dump_child ("chain", DECL_CHAIN (t
));
384 else if (code_class
== tcc_type
)
386 /* All types have qualifiers. */
387 int quals
= lang_hooks
.tree_dump
.type_quals (t
);
389 if (quals
!= TYPE_UNQUALIFIED
)
391 fprintf (di
->stream
, "qual: %c%c%c%c%c%c ",
392 (quals
& TYPE_QUAL_CONST
) ? 'c' : ' ',
393 (quals
& TYPE_QUAL_VOLATILE
) ? 'v' : ' ',
394 (quals
& TYPE_QUAL_RESTRICT
) ? 'r' : ' ',
395 (quals
& TYPE_QUAL_SHARED
) ? 's' : ' ',
396 (quals
& TYPE_QUAL_STRICT
) ? 't' : ' ',
397 (quals
& TYPE_QUAL_RELAXED
) ? 'x' : ' ');
401 /* All types have associated declarations. */
402 dump_child ("name", TYPE_NAME (t
));
404 /* All types have a main variant. */
405 if (TYPE_MAIN_VARIANT (t
) != t
)
406 dump_child ("unql", TYPE_MAIN_VARIANT (t
));
409 dump_child ("size", TYPE_SIZE (t
));
411 /* All types have alignments. */
412 dump_int (di
, "algn", TYPE_ALIGN (t
));
414 else if (code_class
== tcc_constant
)
415 /* All constants can have types. */
416 queue_and_dump_type (di
, t
);
418 /* Give the language-specific code a chance to print something. If
419 it's completely taken care of things, don't bother printing
420 anything more ourselves. */
421 if (lang_hooks
.tree_dump
.dump_tree (di
, t
))
424 /* Now handle the various kinds of nodes. */
429 case IDENTIFIER_NODE
:
430 dump_string_field (di
, "strg", IDENTIFIER_POINTER (t
));
431 dump_int (di
, "lngt", IDENTIFIER_LENGTH (t
));
435 dump_child ("purp", TREE_PURPOSE (t
));
436 dump_child ("valu", TREE_VALUE (t
));
437 dump_child ("chan", TREE_CHAIN (t
));
442 tree_stmt_iterator it
;
443 for (i
= 0, it
= tsi_start (t
); !tsi_end_p (it
); tsi_next (&it
), i
++)
446 sprintf (buffer
, "%u", i
);
447 dump_child (buffer
, tsi_stmt (it
));
453 dump_int (di
, "lngt", TREE_VEC_LENGTH (t
));
454 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
457 sprintf (buffer
, "%u", i
);
458 dump_child (buffer
, TREE_VEC_ELT (t
, i
));
464 dump_int (di
, "prec", TYPE_PRECISION (t
));
465 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
466 dump_child ("min", TYPE_MIN_VALUE (t
));
467 dump_child ("max", TYPE_MAX_VALUE (t
));
469 if (code
== ENUMERAL_TYPE
)
470 dump_child ("csts", TYPE_VALUES (t
));
474 dump_int (di
, "prec", TYPE_PRECISION (t
));
477 case FIXED_POINT_TYPE
:
478 dump_int (di
, "prec", TYPE_PRECISION (t
));
479 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
480 dump_string_field (di
, "saturating",
481 TYPE_SATURATING (t
) ? "saturating": "non-saturating");
485 dump_child ("ptd", TREE_TYPE (t
));
489 dump_child ("refd", TREE_TYPE (t
));
493 dump_child ("clas", TYPE_METHOD_BASETYPE (t
));
497 dump_child ("retn", TREE_TYPE (t
));
498 dump_child ("prms", TYPE_ARG_TYPES (t
));
502 dump_child ("elts", TREE_TYPE (t
));
503 dump_child ("domn", TYPE_DOMAIN (t
));
508 if (TREE_CODE (t
) == RECORD_TYPE
)
509 dump_string_field (di
, "tag", "struct");
511 dump_string_field (di
, "tag", "union");
513 dump_child ("flds", TYPE_FIELDS (t
));
514 dump_child ("fncs", TYPE_METHODS (t
));
515 queue_and_dump_index (di
, "binf", TYPE_BINFO (t
),
520 dump_child ("cnst", DECL_INITIAL (t
));
523 case DEBUG_EXPR_DECL
:
524 dump_int (di
, "-uid", DEBUG_TEMP_UID (t
));
531 if (TREE_CODE (t
) == PARM_DECL
)
532 dump_child ("argt", DECL_ARG_TYPE (t
));
534 dump_child ("init", DECL_INITIAL (t
));
535 dump_child ("size", DECL_SIZE (t
));
536 dump_int (di
, "algn", DECL_ALIGN (t
));
538 if (TREE_CODE (t
) == FIELD_DECL
)
540 if (DECL_FIELD_OFFSET (t
))
541 dump_child ("bpos", bit_position (t
));
543 else if (TREE_CODE (t
) == VAR_DECL
544 || TREE_CODE (t
) == PARM_DECL
)
546 dump_int (di
, "used", TREE_USED (t
));
547 if (DECL_REGISTER (t
))
548 dump_string_field (di
, "spec", "register");
553 dump_child ("args", DECL_ARGUMENTS (t
));
554 if (DECL_EXTERNAL (t
))
555 dump_string_field (di
, "body", "undefined");
557 dump_string_field (di
, "link", "extern");
559 dump_string_field (di
, "link", "static");
560 if (DECL_SAVED_TREE (t
) && !dump_flag (di
, TDF_SLIM
, t
))
561 dump_child ("body", DECL_SAVED_TREE (t
));
565 if (TREE_INT_CST_HIGH (t
))
566 dump_int (di
, "high", TREE_INT_CST_HIGH (t
));
567 dump_int (di
, "low", TREE_INT_CST_LOW (t
));
571 fprintf (di
->stream
, "strg: %-7s ", TREE_STRING_POINTER (t
));
572 dump_int (di
, "lngt", TREE_STRING_LENGTH (t
));
576 dump_real (di
, "valu", TREE_REAL_CST_PTR (t
));
580 dump_fixed (di
, "valu", TREE_FIXED_CST_PTR (t
));
586 case CLEANUP_POINT_EXPR
:
590 /* These nodes are unary, but do not have code class `1'. */
591 dump_child ("op 0", TREE_OPERAND (t
, 0));
594 case TRUTH_ANDIF_EXPR
:
595 case TRUTH_ORIF_EXPR
:
599 case PREDECREMENT_EXPR
:
600 case PREINCREMENT_EXPR
:
601 case POSTDECREMENT_EXPR
:
602 case POSTINCREMENT_EXPR
:
603 /* These nodes are binary, but do not have code class `2'. */
604 dump_child ("op 0", TREE_OPERAND (t
, 0));
605 dump_child ("op 1", TREE_OPERAND (t
, 1));
610 dump_child ("op 0", TREE_OPERAND (t
, 0));
611 dump_child ("op 1", TREE_OPERAND (t
, 1));
612 dump_child ("op 2", TREE_OPERAND (t
, 2));
616 case ARRAY_RANGE_REF
:
617 dump_child ("op 0", TREE_OPERAND (t
, 0));
618 dump_child ("op 1", TREE_OPERAND (t
, 1));
619 dump_child ("op 2", TREE_OPERAND (t
, 2));
620 dump_child ("op 3", TREE_OPERAND (t
, 3));
624 dump_child ("op 0", TREE_OPERAND (t
, 0));
625 dump_child ("op 1", TREE_OPERAND (t
, 1));
626 dump_child ("op 2", TREE_OPERAND (t
, 2));
629 case TRY_FINALLY_EXPR
:
630 dump_child ("op 0", TREE_OPERAND (t
, 0));
631 dump_child ("op 1", TREE_OPERAND (t
, 1));
638 call_expr_arg_iterator iter
;
639 dump_child ("fn", CALL_EXPR_FN (t
));
640 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
643 sprintf (buffer
, "%u", i
);
644 dump_child (buffer
, arg
);
652 unsigned HOST_WIDE_INT cnt
;
654 dump_int (di
, "lngt", vec_safe_length (CONSTRUCTOR_ELTS (t
)));
655 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), cnt
, index
, value
)
657 dump_child ("idx", index
);
658 dump_child ("val", value
);
664 dump_child ("vars", TREE_OPERAND (t
, 0));
665 dump_child ("body", TREE_OPERAND (t
, 1));
669 dump_child ("body", TREE_OPERAND (t
, 0));
673 dump_child ("cond", TREE_OPERAND (t
, 0));
677 dump_child ("expr", TREE_OPERAND (t
, 0));
681 dump_child ("decl", TREE_OPERAND (t
, 0));
682 dump_child ("init", TREE_OPERAND (t
, 1));
683 dump_child ("clnp", TREE_OPERAND (t
, 2));
684 /* There really are two possible places the initializer can be.
685 After RTL expansion, the second operand is moved to the
686 position of the fourth operand, and the second operand
688 dump_child ("init", TREE_OPERAND (t
, 3));
691 case CASE_LABEL_EXPR
:
692 dump_child ("name", CASE_LABEL (t
));
695 dump_child ("low ", CASE_LOW (t
));
697 dump_child ("high", CASE_HIGH (t
));
701 dump_child ("name", TREE_OPERAND (t
,0));
704 dump_child ("labl", TREE_OPERAND (t
, 0));
707 dump_child ("cond", TREE_OPERAND (t
, 0));
708 dump_child ("body", TREE_OPERAND (t
, 1));
709 if (TREE_OPERAND (t
, 2))
711 dump_child ("labl", TREE_OPERAND (t
,2));
717 fprintf (di
->stream
, "%s\n", omp_clause_code_name
[OMP_CLAUSE_CODE (t
)]);
718 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
719 dump_child ("op: ", OMP_CLAUSE_OPERAND (t
, i
));
723 /* There are no additional fields to print. */
728 if (dump_flag (di
, TDF_ADDRESS
, NULL
))
729 dump_pointer (di
, "addr", (void *)t
);
731 /* Terminate the line. */
732 fprintf (di
->stream
, "\n");
735 /* Return nonzero if FLAG has been specified for the dump, and NODE
736 is not the root node of the dump. */
738 int dump_flag (dump_info_p di
, int flag
, const_tree node
)
740 return (di
->flags
& flag
) && (node
!= di
->node
);
743 /* Dump T, and all its children, on STREAM. */
746 dump_node (const_tree t
, int flags
, FILE *stream
)
750 dump_queue_p next_dq
;
752 /* Initialize the dump-information structure. */
761 di
.nodes
= splay_tree_new (splay_tree_compare_pointers
, 0,
762 (splay_tree_delete_value_fn
) &free
);
764 /* Queue up the first node. */
765 queue (&di
, t
, DUMP_NONE
);
767 /* Until the queue is empty, keep dumping nodes. */
769 dequeue_and_dump (&di
);
772 for (dq
= di
.free_list
; dq
; dq
= next_dq
)
777 splay_tree_delete (di
.nodes
);