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 "diagnostic-core.h"
31 #include "tree-dump.h"
32 #include "tree-pass.h"
33 #include "langhooks.h"
34 #include "tree-iterator.h"
36 /* If non-NULL, return one past-the-end of the matching SUBPART of
38 #define skip_leading_substring(whole, part) \
39 (strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part))
41 static unsigned int queue (dump_info_p
, const_tree
, int);
42 static void dump_index (dump_info_p
, unsigned int);
43 static void dequeue_and_dump (dump_info_p
);
44 static void dump_new_line (dump_info_p
);
45 static void dump_maybe_newline (dump_info_p
);
47 /* Add T to the end of the queue of nodes to dump. Returns the index
51 queue (dump_info_p di
, const_tree t
, int flags
)
57 /* Assign the next available index to T. */
60 /* Obtain a new queue node. */
64 di
->free_list
= dq
->next
;
67 dq
= XNEW (struct dump_queue
);
69 /* Create a new entry in the splay-tree. */
70 dni
= XNEW (struct dump_node_info
);
72 dni
->binfo_p
= ((flags
& DUMP_BINFO
) != 0);
73 dq
->node
= splay_tree_insert (di
->nodes
, (splay_tree_key
) t
,
74 (splay_tree_value
) dni
);
76 /* Add it to the end of the queue. */
81 di
->queue_end
->next
= dq
;
84 /* Return the index. */
89 dump_index (dump_info_p di
, unsigned int index
)
91 fprintf (di
->stream
, "@%-6u ", index
);
95 /* If T has not already been output, queue it for subsequent output.
96 FIELD is a string to print before printing the index. Then, the
97 index of T is printed. */
100 queue_and_dump_index (dump_info_p di
, const char *field
, const_tree t
, int flags
)
105 /* If there's no node, just return. This makes for fewer checks in
110 /* See if we've already queued or dumped this node. */
111 n
= splay_tree_lookup (di
->nodes
, (splay_tree_key
) t
);
113 index
= ((dump_node_info_p
) n
->value
)->index
;
115 /* If we haven't, add it to the queue. */
116 index
= queue (di
, t
, flags
);
118 /* Print the index of the node. */
119 dump_maybe_newline (di
);
120 fprintf (di
->stream
, "%-4s: ", field
);
122 dump_index (di
, index
);
125 /* Dump the type of T. */
128 queue_and_dump_type (dump_info_p di
, const_tree t
)
130 queue_and_dump_index (di
, "type", TREE_TYPE (t
), DUMP_NONE
);
133 /* Dump column control */
134 #define SOL_COLUMN 25 /* Start of line column. */
135 #define EOL_COLUMN 55 /* End of line column. */
136 #define COLUMN_ALIGNMENT 15 /* Alignment. */
138 /* Insert a new line in the dump output, and indent to an appropriate
139 place to start printing more fields. */
142 dump_new_line (dump_info_p di
)
144 fprintf (di
->stream
, "\n%*s", SOL_COLUMN
, "");
145 di
->column
= SOL_COLUMN
;
148 /* If necessary, insert a new line. */
151 dump_maybe_newline (dump_info_p di
)
155 /* See if we need a new line. */
156 if (di
->column
> EOL_COLUMN
)
158 /* See if we need any padding. */
159 else if ((extra
= (di
->column
- SOL_COLUMN
) % COLUMN_ALIGNMENT
) != 0)
161 fprintf (di
->stream
, "%*s", COLUMN_ALIGNMENT
- extra
, "");
162 di
->column
+= COLUMN_ALIGNMENT
- extra
;
166 /* Dump pointer PTR using FIELD to identify it. */
169 dump_pointer (dump_info_p di
, const char *field
, void *ptr
)
171 dump_maybe_newline (di
);
172 fprintf (di
->stream
, "%-4s: %-8lx ", field
, (unsigned long) ptr
);
176 /* Dump integer I using FIELD to identify it. */
179 dump_int (dump_info_p di
, const char *field
, int i
)
181 dump_maybe_newline (di
);
182 fprintf (di
->stream
, "%-4s: %-7d ", field
, i
);
186 /* Dump the floating point value R, using FIELD to identify it. */
189 dump_real (dump_info_p di
, const char *field
, const REAL_VALUE_TYPE
*r
)
192 real_to_decimal (buf
, r
, sizeof (buf
), 0, true);
193 dump_maybe_newline (di
);
194 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
195 di
->column
+= strlen (buf
) + 7;
198 /* Dump the fixed-point value F, using FIELD to identify it. */
201 dump_fixed (dump_info_p di
, const char *field
, const FIXED_VALUE_TYPE
*f
)
204 fixed_to_decimal (buf
, f
, sizeof (buf
));
205 dump_maybe_newline (di
);
206 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
207 di
->column
+= strlen (buf
) + 7;
211 /* Dump the string S. */
214 dump_string (dump_info_p di
, const char *string
)
216 dump_maybe_newline (di
);
217 fprintf (di
->stream
, "%-13s ", string
);
218 if (strlen (string
) > 13)
219 di
->column
+= strlen (string
) + 1;
224 /* Dump the string field S. */
227 dump_string_field (dump_info_p di
, const char *field
, const char *string
)
229 dump_maybe_newline (di
);
230 fprintf (di
->stream
, "%-4s: %-7s ", field
, string
);
231 if (strlen (string
) > 7)
232 di
->column
+= 6 + strlen (string
) + 1;
237 /* Dump the next node in the queue. */
240 dequeue_and_dump (dump_info_p di
)
244 dump_node_info_p dni
;
248 enum tree_code_class code_class
;
249 const char* code_name
;
251 /* Get the next node from the queue. */
255 dni
= (dump_node_info_p
) stn
->value
;
258 /* Remove the node from the queue, and put it on the free list. */
259 di
->queue
= dq
->next
;
262 dq
->next
= di
->free_list
;
265 /* Print the node index. */
266 dump_index (di
, index
);
267 /* And the type of node this is. */
271 code_name
= tree_code_name
[(int) TREE_CODE (t
)];
272 fprintf (di
->stream
, "%-16s ", code_name
);
275 /* Figure out what kind of node this is. */
276 code
= TREE_CODE (t
);
277 code_class
= TREE_CODE_CLASS (code
);
279 /* Although BINFOs are TREE_VECs, we dump them specially so as to be
285 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (t
);
287 dump_child ("type", BINFO_TYPE (t
));
289 if (BINFO_VIRTUAL_P (t
))
290 dump_string_field (di
, "spec", "virt");
292 dump_int (di
, "bases", BINFO_N_BASE_BINFOS (t
));
293 for (ix
= 0; BINFO_BASE_ITERATE (t
, ix
, base
); ix
++)
295 tree access
= (accesses
? VEC_index (tree
, accesses
, ix
)
296 : access_public_node
);
297 const char *string
= NULL
;
299 if (access
== access_public_node
)
301 else if (access
== access_protected_node
)
303 else if (access
== access_private_node
)
308 dump_string_field (di
, "accs", string
);
309 queue_and_dump_index (di
, "binf", base
, DUMP_BINFO
);
315 /* We can knock off a bunch of expression nodes in exactly the same
317 if (IS_EXPR_CODE_CLASS (code_class
))
319 /* If we're dumping children, dump them now. */
320 queue_and_dump_type (di
, t
);
325 dump_child ("op 0", TREE_OPERAND (t
, 0));
330 dump_child ("op 0", TREE_OPERAND (t
, 0));
331 dump_child ("op 1", TREE_OPERAND (t
, 1));
338 /* These nodes are handled explicitly below. */
347 expanded_location xloc
;
348 /* All declarations have names. */
350 dump_child ("name", DECL_NAME (t
));
351 if (DECL_ASSEMBLER_NAME_SET_P (t
)
352 && DECL_ASSEMBLER_NAME (t
) != DECL_NAME (t
))
353 dump_child ("mngl", DECL_ASSEMBLER_NAME (t
));
354 if (DECL_ABSTRACT_ORIGIN (t
))
355 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t
));
357 queue_and_dump_type (di
, t
);
358 dump_child ("scpe", DECL_CONTEXT (t
));
359 /* And a source position. */
360 xloc
= expand_location (DECL_SOURCE_LOCATION (t
));
363 const char *filename
= lbasename (xloc
.file
);
365 dump_maybe_newline (di
);
366 fprintf (di
->stream
, "srcp: %s:%-6d ", filename
,
368 di
->column
+= 6 + strlen (filename
) + 8;
370 /* And any declaration can be compiler-generated. */
371 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_COMMON
)
372 && DECL_ARTIFICIAL (t
))
373 dump_string_field (di
, "note", "artificial");
374 if (DECL_CHAIN (t
) && !dump_flag (di
, TDF_SLIM
, NULL
))
375 dump_child ("chain", DECL_CHAIN (t
));
377 else if (code_class
== tcc_type
)
379 /* All types have qualifiers. */
380 int quals
= lang_hooks
.tree_dump
.type_quals (t
);
382 if (quals
!= TYPE_UNQUALIFIED
)
384 fprintf (di
->stream
, "qual: %c%c%c ",
385 (quals
& TYPE_QUAL_CONST
) ? 'c' : ' ',
386 (quals
& TYPE_QUAL_VOLATILE
) ? 'v' : ' ',
387 (quals
& TYPE_QUAL_RESTRICT
) ? 'r' : ' ');
391 /* All types have associated declarations. */
392 dump_child ("name", TYPE_NAME (t
));
394 /* All types have a main variant. */
395 if (TYPE_MAIN_VARIANT (t
) != t
)
396 dump_child ("unql", TYPE_MAIN_VARIANT (t
));
399 dump_child ("size", TYPE_SIZE (t
));
401 /* All types have alignments. */
402 dump_int (di
, "algn", TYPE_ALIGN (t
));
404 else if (code_class
== tcc_constant
)
405 /* All constants can have types. */
406 queue_and_dump_type (di
, t
);
408 /* Give the language-specific code a chance to print something. If
409 it's completely taken care of things, don't bother printing
410 anything more ourselves. */
411 if (lang_hooks
.tree_dump
.dump_tree (di
, t
))
414 /* Now handle the various kinds of nodes. */
419 case IDENTIFIER_NODE
:
420 dump_string_field (di
, "strg", IDENTIFIER_POINTER (t
));
421 dump_int (di
, "lngt", IDENTIFIER_LENGTH (t
));
425 dump_child ("purp", TREE_PURPOSE (t
));
426 dump_child ("valu", TREE_VALUE (t
));
427 dump_child ("chan", TREE_CHAIN (t
));
432 tree_stmt_iterator it
;
433 for (i
= 0, it
= tsi_start (t
); !tsi_end_p (it
); tsi_next (&it
), i
++)
436 sprintf (buffer
, "%u", i
);
437 dump_child (buffer
, tsi_stmt (it
));
443 dump_int (di
, "lngt", TREE_VEC_LENGTH (t
));
444 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
447 sprintf (buffer
, "%u", i
);
448 dump_child (buffer
, TREE_VEC_ELT (t
, i
));
454 dump_int (di
, "prec", TYPE_PRECISION (t
));
455 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
456 dump_child ("min", TYPE_MIN_VALUE (t
));
457 dump_child ("max", TYPE_MAX_VALUE (t
));
459 if (code
== ENUMERAL_TYPE
)
460 dump_child ("csts", TYPE_VALUES (t
));
464 dump_int (di
, "prec", TYPE_PRECISION (t
));
467 case FIXED_POINT_TYPE
:
468 dump_int (di
, "prec", TYPE_PRECISION (t
));
469 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
470 dump_string_field (di
, "saturating",
471 TYPE_SATURATING (t
) ? "saturating": "non-saturating");
475 dump_child ("ptd", TREE_TYPE (t
));
479 dump_child ("refd", TREE_TYPE (t
));
483 dump_child ("clas", TYPE_METHOD_BASETYPE (t
));
487 dump_child ("retn", TREE_TYPE (t
));
488 dump_child ("prms", TYPE_ARG_TYPES (t
));
492 dump_child ("elts", TREE_TYPE (t
));
493 dump_child ("domn", TYPE_DOMAIN (t
));
498 if (TREE_CODE (t
) == RECORD_TYPE
)
499 dump_string_field (di
, "tag", "struct");
501 dump_string_field (di
, "tag", "union");
503 dump_child ("flds", TYPE_FIELDS (t
));
504 dump_child ("fncs", TYPE_METHODS (t
));
505 queue_and_dump_index (di
, "binf", TYPE_BINFO (t
),
510 dump_child ("cnst", DECL_INITIAL (t
));
513 case DEBUG_EXPR_DECL
:
514 dump_int (di
, "-uid", DEBUG_TEMP_UID (t
));
521 if (TREE_CODE (t
) == PARM_DECL
)
522 dump_child ("argt", DECL_ARG_TYPE (t
));
524 dump_child ("init", DECL_INITIAL (t
));
525 dump_child ("size", DECL_SIZE (t
));
526 dump_int (di
, "algn", DECL_ALIGN (t
));
528 if (TREE_CODE (t
) == FIELD_DECL
)
530 if (DECL_FIELD_OFFSET (t
))
531 dump_child ("bpos", bit_position (t
));
533 else if (TREE_CODE (t
) == VAR_DECL
534 || TREE_CODE (t
) == PARM_DECL
)
536 dump_int (di
, "used", TREE_USED (t
));
537 if (DECL_REGISTER (t
))
538 dump_string_field (di
, "spec", "register");
543 dump_child ("args", DECL_ARGUMENTS (t
));
544 if (DECL_EXTERNAL (t
))
545 dump_string_field (di
, "body", "undefined");
547 dump_string_field (di
, "link", "extern");
549 dump_string_field (di
, "link", "static");
550 if (DECL_SAVED_TREE (t
) && !dump_flag (di
, TDF_SLIM
, t
))
551 dump_child ("body", DECL_SAVED_TREE (t
));
555 if (TREE_INT_CST_HIGH (t
))
556 dump_int (di
, "high", TREE_INT_CST_HIGH (t
));
557 dump_int (di
, "low", TREE_INT_CST_LOW (t
));
561 fprintf (di
->stream
, "strg: %-7s ", TREE_STRING_POINTER (t
));
562 dump_int (di
, "lngt", TREE_STRING_LENGTH (t
));
566 dump_real (di
, "valu", TREE_REAL_CST_PTR (t
));
570 dump_fixed (di
, "valu", TREE_FIXED_CST_PTR (t
));
576 case CLEANUP_POINT_EXPR
:
580 /* These nodes are unary, but do not have code class `1'. */
581 dump_child ("op 0", TREE_OPERAND (t
, 0));
584 case TRUTH_ANDIF_EXPR
:
585 case TRUTH_ORIF_EXPR
:
589 case PREDECREMENT_EXPR
:
590 case PREINCREMENT_EXPR
:
591 case POSTDECREMENT_EXPR
:
592 case POSTINCREMENT_EXPR
:
593 /* These nodes are binary, but do not have code class `2'. */
594 dump_child ("op 0", TREE_OPERAND (t
, 0));
595 dump_child ("op 1", TREE_OPERAND (t
, 1));
600 dump_child ("op 0", TREE_OPERAND (t
, 0));
601 dump_child ("op 1", TREE_OPERAND (t
, 1));
602 dump_child ("op 2", TREE_OPERAND (t
, 2));
606 case ARRAY_RANGE_REF
:
607 dump_child ("op 0", TREE_OPERAND (t
, 0));
608 dump_child ("op 1", TREE_OPERAND (t
, 1));
609 dump_child ("op 2", TREE_OPERAND (t
, 2));
610 dump_child ("op 3", TREE_OPERAND (t
, 3));
614 dump_child ("op 0", TREE_OPERAND (t
, 0));
615 dump_child ("op 1", TREE_OPERAND (t
, 1));
616 dump_child ("op 2", TREE_OPERAND (t
, 2));
619 case TRY_FINALLY_EXPR
:
620 dump_child ("op 0", TREE_OPERAND (t
, 0));
621 dump_child ("op 1", TREE_OPERAND (t
, 1));
628 call_expr_arg_iterator iter
;
629 dump_child ("fn", CALL_EXPR_FN (t
));
630 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
633 sprintf (buffer
, "%u", i
);
634 dump_child (buffer
, arg
);
642 unsigned HOST_WIDE_INT cnt
;
644 dump_int (di
, "lngt", VEC_length (constructor_elt
,
645 CONSTRUCTOR_ELTS (t
)));
646 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), cnt
, index
, value
)
648 dump_child ("idx", index
);
649 dump_child ("val", value
);
655 dump_child ("vars", TREE_OPERAND (t
, 0));
656 dump_child ("body", TREE_OPERAND (t
, 1));
660 dump_child ("body", TREE_OPERAND (t
, 0));
664 dump_child ("cond", TREE_OPERAND (t
, 0));
668 dump_child ("expr", TREE_OPERAND (t
, 0));
672 dump_child ("decl", TREE_OPERAND (t
, 0));
673 dump_child ("init", TREE_OPERAND (t
, 1));
674 dump_child ("clnp", TREE_OPERAND (t
, 2));
675 /* There really are two possible places the initializer can be.
676 After RTL expansion, the second operand is moved to the
677 position of the fourth operand, and the second operand
679 dump_child ("init", TREE_OPERAND (t
, 3));
682 case CASE_LABEL_EXPR
:
683 dump_child ("name", CASE_LABEL (t
));
686 dump_child ("low ", CASE_LOW (t
));
688 dump_child ("high", CASE_HIGH (t
));
692 dump_child ("name", TREE_OPERAND (t
,0));
695 dump_child ("labl", TREE_OPERAND (t
, 0));
698 dump_child ("cond", TREE_OPERAND (t
, 0));
699 dump_child ("body", TREE_OPERAND (t
, 1));
700 if (TREE_OPERAND (t
, 2))
702 dump_child ("labl", TREE_OPERAND (t
,2));
708 fprintf (di
->stream
, "%s\n", omp_clause_code_name
[OMP_CLAUSE_CODE (t
)]);
709 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
710 dump_child ("op: ", OMP_CLAUSE_OPERAND (t
, i
));
714 /* There are no additional fields to print. */
719 if (dump_flag (di
, TDF_ADDRESS
, NULL
))
720 dump_pointer (di
, "addr", (void *)t
);
722 /* Terminate the line. */
723 fprintf (di
->stream
, "\n");
726 /* Return nonzero if FLAG has been specified for the dump, and NODE
727 is not the root node of the dump. */
729 int dump_flag (dump_info_p di
, int flag
, const_tree node
)
731 return (di
->flags
& flag
) && (node
!= di
->node
);
734 /* Dump T, and all its children, on STREAM. */
737 dump_node (const_tree t
, int flags
, FILE *stream
)
741 dump_queue_p next_dq
;
743 /* Initialize the dump-information structure. */
752 di
.nodes
= splay_tree_new (splay_tree_compare_pointers
, 0,
753 (splay_tree_delete_value_fn
) &free
);
755 /* Queue up the first node. */
756 queue (&di
, t
, DUMP_NONE
);
758 /* Until the queue is empty, keep dumping nodes. */
760 dequeue_and_dump (&di
);
763 for (dq
= di
.free_list
; dq
; dq
= next_dq
)
768 splay_tree_delete (di
.nodes
);
772 /* Table of tree dump switches. This must be consistent with the
773 tree_dump_index enumeration in tree-pass.h. */
774 static struct dump_file_info dump_files
[TDI_end
] =
776 {NULL
, NULL
, NULL
, 0, 0, 0},
777 {".cgraph", "ipa-cgraph", NULL
, TDF_IPA
, 0, 0},
778 {".tu", "translation-unit", NULL
, TDF_TREE
, 0, 1},
779 {".class", "class-hierarchy", NULL
, TDF_TREE
, 0, 2},
780 {".original", "tree-original", NULL
, TDF_TREE
, 0, 3},
781 {".gimple", "tree-gimple", NULL
, TDF_TREE
, 0, 4},
782 {".nested", "tree-nested", NULL
, TDF_TREE
, 0, 5},
783 {".vcg", "tree-vcg", NULL
, TDF_TREE
, 0, 6},
784 {".ads", "ada-spec", NULL
, 0, 0, 7},
785 #define FIRST_AUTO_NUMBERED_DUMP 8
787 {NULL
, "tree-all", NULL
, TDF_TREE
, 0, 0},
788 {NULL
, "rtl-all", NULL
, TDF_RTL
, 0, 0},
789 {NULL
, "ipa-all", NULL
, TDF_IPA
, 0, 0},
792 /* Dynamically registered tree dump files and switches. */
793 static struct dump_file_info
*extra_dump_files
;
794 static size_t extra_dump_files_in_use
;
795 static size_t extra_dump_files_alloced
;
797 /* Define a name->number mapping for a dump flag value. */
798 struct dump_option_value_info
800 const char *const name
; /* the name of the value */
801 const int value
; /* the value of the name */
804 /* Table of dump options. This must be consistent with the TDF_* flags
806 static const struct dump_option_value_info dump_options
[] =
808 {"address", TDF_ADDRESS
},
809 {"asmname", TDF_ASMNAME
},
812 {"graph", TDF_GRAPH
},
813 {"details", TDF_DETAILS
},
814 {"cselib", TDF_CSELIB
},
815 {"stats", TDF_STATS
},
816 {"blocks", TDF_BLOCKS
},
818 {"lineno", TDF_LINENO
},
820 {"stmtaddr", TDF_STMTADDR
},
821 {"memsyms", TDF_MEMSYMS
},
822 {"verbose", TDF_VERBOSE
},
824 {"alias", TDF_ALIAS
},
825 {"nouid", TDF_NOUID
},
826 {"enumerate_locals", TDF_ENUMERATE_LOCALS
},
828 {"all", ~(TDF_RAW
| TDF_SLIM
| TDF_LINENO
| TDF_TREE
| TDF_RTL
| TDF_IPA
829 | TDF_STMTADDR
| TDF_GRAPH
| TDF_DIAGNOSTIC
| TDF_VERBOSE
830 | TDF_RHS_ONLY
| TDF_NOUID
| TDF_ENUMERATE_LOCALS
| TDF_SCEV
)},
835 dump_register (const char *suffix
, const char *swtch
, const char *glob
,
838 static int next_dump
= FIRST_AUTO_NUMBERED_DUMP
;
839 int num
= next_dump
++;
841 size_t count
= extra_dump_files_in_use
++;
843 if (count
>= extra_dump_files_alloced
)
845 if (extra_dump_files_alloced
== 0)
846 extra_dump_files_alloced
= 32;
848 extra_dump_files_alloced
*= 2;
849 extra_dump_files
= XRESIZEVEC (struct dump_file_info
,
851 extra_dump_files_alloced
);
854 memset (&extra_dump_files
[count
], 0, sizeof (struct dump_file_info
));
855 extra_dump_files
[count
].suffix
= suffix
;
856 extra_dump_files
[count
].swtch
= swtch
;
857 extra_dump_files
[count
].glob
= glob
;
858 extra_dump_files
[count
].flags
= flags
;
859 extra_dump_files
[count
].num
= num
;
861 return count
+ TDI_end
;
865 /* Return the dump_file_info for the given phase. */
867 struct dump_file_info
*
868 get_dump_file_info (int phase
)
871 return &dump_files
[phase
];
872 else if ((size_t) (phase
- TDI_end
) >= extra_dump_files_in_use
)
875 return extra_dump_files
+ (phase
- TDI_end
);
879 /* Return the name of the dump file for the given phase.
880 If the dump is not enabled, returns NULL. */
883 get_dump_file_name (int phase
)
886 struct dump_file_info
*dfi
;
888 if (phase
== TDI_none
)
891 dfi
= get_dump_file_info (phase
);
900 if (dfi
->flags
& TDF_TREE
)
902 else if (dfi
->flags
& TDF_IPA
)
907 if (snprintf (dump_id
, sizeof (dump_id
), ".%03d%c", dfi
->num
, suffix
) < 0)
911 return concat (dump_base_name
, dump_id
, dfi
->suffix
, NULL
);
914 /* Begin a tree dump for PHASE. Stores any user supplied flag in
915 *FLAG_PTR and returns a stream to write to. If the dump is not
916 enabled, returns NULL.
917 Multiple calls will reopen and append to the dump file. */
920 dump_begin (int phase
, int *flag_ptr
)
923 struct dump_file_info
*dfi
;
926 if (phase
== TDI_none
|| !dump_enabled_p (phase
))
929 name
= get_dump_file_name (phase
);
930 dfi
= get_dump_file_info (phase
);
931 stream
= fopen (name
, dfi
->state
< 0 ? "w" : "a");
933 error ("could not open dump file %qs: %m", name
);
939 *flag_ptr
= dfi
->flags
;
944 /* Returns nonzero if tree dump PHASE is enabled. If PHASE is
945 TDI_tree_all, return nonzero if any dump is enabled. */
948 dump_enabled_p (int phase
)
950 if (phase
== TDI_tree_all
)
953 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
954 if (dump_files
[i
].state
)
956 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
957 if (extra_dump_files
[i
].state
)
963 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
968 /* Returns nonzero if tree dump PHASE has been initialized. */
971 dump_initialized_p (int phase
)
973 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
974 return dfi
->state
> 0;
977 /* Returns the switch name of PHASE. */
980 dump_flag_name (int phase
)
982 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
986 /* Finish a tree dump for PHASE. STREAM is the stream created by
990 dump_end (int phase ATTRIBUTE_UNUSED
, FILE *stream
)
995 /* Enable all tree dumps. Return number of enabled tree dumps. */
998 dump_enable_all (int flags
)
1000 int ir_dump_type
= (flags
& (TDF_TREE
| TDF_RTL
| TDF_IPA
));
1004 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1005 if ((dump_files
[i
].flags
& ir_dump_type
))
1007 dump_files
[i
].state
= -1;
1008 dump_files
[i
].flags
|= flags
;
1012 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1013 if ((extra_dump_files
[i
].flags
& ir_dump_type
))
1015 extra_dump_files
[i
].state
= -1;
1016 extra_dump_files
[i
].flags
|= flags
;
1023 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1024 relevant details in the dump_files array. */
1027 dump_switch_p_1 (const char *arg
, struct dump_file_info
*dfi
, bool doglob
)
1029 const char *option_value
;
1033 if (doglob
&& !dfi
->glob
)
1036 option_value
= skip_leading_substring (arg
, doglob
? dfi
->glob
: dfi
->swtch
);
1040 if (*option_value
&& *option_value
!= '-')
1048 const struct dump_option_value_info
*option_ptr
;
1049 const char *end_ptr
;
1054 end_ptr
= strchr (ptr
, '-');
1056 end_ptr
= ptr
+ strlen (ptr
);
1057 length
= end_ptr
- ptr
;
1059 for (option_ptr
= dump_options
; option_ptr
->name
; option_ptr
++)
1060 if (strlen (option_ptr
->name
) == length
1061 && !memcmp (option_ptr
->name
, ptr
, length
))
1063 flags
|= option_ptr
->value
;
1066 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1067 length
, ptr
, dfi
->swtch
);
1073 dfi
->flags
|= flags
;
1075 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1077 if (dfi
->suffix
== NULL
)
1078 dump_enable_all (dfi
->flags
);
1084 dump_switch_p (const char *arg
)
1089 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1090 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], false);
1092 /* Don't glob if we got a hit already */
1094 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1095 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], true);
1097 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1098 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], false);
1101 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1102 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], true);
1108 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1111 dump_function (int phase
, tree fn
)
1116 stream
= dump_begin (phase
, &flags
);
1119 dump_function_to_file (fn
, stream
, flags
);
1120 dump_end (phase
, stream
);
1125 enable_rtl_dump_file (void)
1127 return dump_enable_all (TDF_RTL
| TDF_DETAILS
| TDF_BLOCKS
) > 0;