1 /* Tree-dumping functionality for intermediate representation.
2 Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010, 2011 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: %-8" HOST_WIDE_INT_PRINT
"x ", field
,
173 (unsigned HOST_WIDE_INT
) (uintptr_t) ptr
);
177 /* Dump integer I using FIELD to identify it. */
180 dump_int (dump_info_p di
, const char *field
, int i
)
182 dump_maybe_newline (di
);
183 fprintf (di
->stream
, "%-4s: %-7d ", field
, i
);
187 /* Dump the floating point value R, using FIELD to identify it. */
190 dump_real (dump_info_p di
, const char *field
, const REAL_VALUE_TYPE
*r
)
193 real_to_decimal (buf
, r
, sizeof (buf
), 0, true);
194 dump_maybe_newline (di
);
195 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
196 di
->column
+= strlen (buf
) + 7;
199 /* Dump the fixed-point value F, using FIELD to identify it. */
202 dump_fixed (dump_info_p di
, const char *field
, const FIXED_VALUE_TYPE
*f
)
205 fixed_to_decimal (buf
, f
, sizeof (buf
));
206 dump_maybe_newline (di
);
207 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
208 di
->column
+= strlen (buf
) + 7;
212 /* Dump the string S. */
215 dump_string (dump_info_p di
, const char *string
)
217 dump_maybe_newline (di
);
218 fprintf (di
->stream
, "%-13s ", string
);
219 if (strlen (string
) > 13)
220 di
->column
+= strlen (string
) + 1;
225 /* Dump the string field S. */
228 dump_string_field (dump_info_p di
, const char *field
, const char *string
)
230 dump_maybe_newline (di
);
231 fprintf (di
->stream
, "%-4s: %-7s ", field
, string
);
232 if (strlen (string
) > 7)
233 di
->column
+= 6 + strlen (string
) + 1;
238 /* Dump the next node in the queue. */
241 dequeue_and_dump (dump_info_p di
)
245 dump_node_info_p dni
;
249 enum tree_code_class code_class
;
250 const char* code_name
;
252 /* Get the next node from the queue. */
256 dni
= (dump_node_info_p
) stn
->value
;
259 /* Remove the node from the queue, and put it on the free list. */
260 di
->queue
= dq
->next
;
263 dq
->next
= di
->free_list
;
266 /* Print the node index. */
267 dump_index (di
, index
);
268 /* And the type of node this is. */
272 code_name
= tree_code_name
[(int) TREE_CODE (t
)];
273 fprintf (di
->stream
, "%-16s ", code_name
);
276 /* Figure out what kind of node this is. */
277 code
= TREE_CODE (t
);
278 code_class
= TREE_CODE_CLASS (code
);
280 /* Although BINFOs are TREE_VECs, we dump them specially so as to be
286 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (t
);
288 dump_child ("type", BINFO_TYPE (t
));
290 if (BINFO_VIRTUAL_P (t
))
291 dump_string_field (di
, "spec", "virt");
293 dump_int (di
, "bases", BINFO_N_BASE_BINFOS (t
));
294 for (ix
= 0; BINFO_BASE_ITERATE (t
, ix
, base
); ix
++)
296 tree access
= (accesses
? VEC_index (tree
, accesses
, ix
)
297 : access_public_node
);
298 const char *string
= NULL
;
300 if (access
== access_public_node
)
302 else if (access
== access_protected_node
)
304 else if (access
== access_private_node
)
309 dump_string_field (di
, "accs", string
);
310 queue_and_dump_index (di
, "binf", base
, DUMP_BINFO
);
316 /* We can knock off a bunch of expression nodes in exactly the same
318 if (IS_EXPR_CODE_CLASS (code_class
))
320 /* If we're dumping children, dump them now. */
321 queue_and_dump_type (di
, t
);
326 dump_child ("op 0", TREE_OPERAND (t
, 0));
331 dump_child ("op 0", TREE_OPERAND (t
, 0));
332 dump_child ("op 1", TREE_OPERAND (t
, 1));
339 /* These nodes are handled explicitly below. */
348 expanded_location xloc
;
349 /* All declarations have names. */
351 dump_child ("name", DECL_NAME (t
));
352 if (DECL_ASSEMBLER_NAME_SET_P (t
)
353 && DECL_ASSEMBLER_NAME (t
) != DECL_NAME (t
))
354 dump_child ("mngl", DECL_ASSEMBLER_NAME (t
));
355 if (DECL_ABSTRACT_ORIGIN (t
))
356 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t
));
358 queue_and_dump_type (di
, t
);
359 dump_child ("scpe", DECL_CONTEXT (t
));
360 /* And a source position. */
361 xloc
= expand_location (DECL_SOURCE_LOCATION (t
));
364 const char *filename
= lbasename (xloc
.file
);
366 dump_maybe_newline (di
);
367 fprintf (di
->stream
, "srcp: %s:%-6d ", filename
,
369 di
->column
+= 6 + strlen (filename
) + 8;
371 /* And any declaration can be compiler-generated. */
372 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_COMMON
)
373 && DECL_ARTIFICIAL (t
))
374 dump_string_field (di
, "note", "artificial");
375 if (DECL_CHAIN (t
) && !dump_flag (di
, TDF_SLIM
, NULL
))
376 dump_child ("chain", DECL_CHAIN (t
));
378 else if (code_class
== tcc_type
)
380 /* All types have qualifiers. */
381 int quals
= lang_hooks
.tree_dump
.type_quals (t
);
383 if (quals
!= TYPE_UNQUALIFIED
)
385 fprintf (di
->stream
, "qual: %c%c%c ",
386 (quals
& TYPE_QUAL_CONST
) ? 'c' : ' ',
387 (quals
& TYPE_QUAL_VOLATILE
) ? 'v' : ' ',
388 (quals
& TYPE_QUAL_RESTRICT
) ? 'r' : ' ');
392 /* All types have associated declarations. */
393 dump_child ("name", TYPE_NAME (t
));
395 /* All types have a main variant. */
396 if (TYPE_MAIN_VARIANT (t
) != t
)
397 dump_child ("unql", TYPE_MAIN_VARIANT (t
));
400 dump_child ("size", TYPE_SIZE (t
));
402 /* All types have alignments. */
403 dump_int (di
, "algn", TYPE_ALIGN (t
));
405 else if (code_class
== tcc_constant
)
406 /* All constants can have types. */
407 queue_and_dump_type (di
, t
);
409 /* Give the language-specific code a chance to print something. If
410 it's completely taken care of things, don't bother printing
411 anything more ourselves. */
412 if (lang_hooks
.tree_dump
.dump_tree (di
, t
))
415 /* Now handle the various kinds of nodes. */
420 case IDENTIFIER_NODE
:
421 dump_string_field (di
, "strg", IDENTIFIER_POINTER (t
));
422 dump_int (di
, "lngt", IDENTIFIER_LENGTH (t
));
426 dump_child ("purp", TREE_PURPOSE (t
));
427 dump_child ("valu", TREE_VALUE (t
));
428 dump_child ("chan", TREE_CHAIN (t
));
433 tree_stmt_iterator it
;
434 for (i
= 0, it
= tsi_start (t
); !tsi_end_p (it
); tsi_next (&it
), i
++)
437 sprintf (buffer
, "%u", i
);
438 dump_child (buffer
, tsi_stmt (it
));
444 dump_int (di
, "lngt", TREE_VEC_LENGTH (t
));
445 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
448 sprintf (buffer
, "%u", i
);
449 dump_child (buffer
, TREE_VEC_ELT (t
, i
));
455 dump_int (di
, "prec", TYPE_PRECISION (t
));
456 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
457 dump_child ("min", TYPE_MIN_VALUE (t
));
458 dump_child ("max", TYPE_MAX_VALUE (t
));
460 if (code
== ENUMERAL_TYPE
)
461 dump_child ("csts", TYPE_VALUES (t
));
465 dump_int (di
, "prec", TYPE_PRECISION (t
));
468 case FIXED_POINT_TYPE
:
469 dump_int (di
, "prec", TYPE_PRECISION (t
));
470 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
471 dump_string_field (di
, "saturating",
472 TYPE_SATURATING (t
) ? "saturating": "non-saturating");
476 dump_child ("ptd", TREE_TYPE (t
));
480 dump_child ("refd", TREE_TYPE (t
));
484 dump_child ("clas", TYPE_METHOD_BASETYPE (t
));
488 dump_child ("retn", TREE_TYPE (t
));
489 dump_child ("prms", TYPE_ARG_TYPES (t
));
493 dump_child ("elts", TREE_TYPE (t
));
494 dump_child ("domn", TYPE_DOMAIN (t
));
499 if (TREE_CODE (t
) == RECORD_TYPE
)
500 dump_string_field (di
, "tag", "struct");
502 dump_string_field (di
, "tag", "union");
504 dump_child ("flds", TYPE_FIELDS (t
));
505 dump_child ("fncs", TYPE_METHODS (t
));
506 queue_and_dump_index (di
, "binf", TYPE_BINFO (t
),
511 dump_child ("cnst", DECL_INITIAL (t
));
514 case DEBUG_EXPR_DECL
:
515 dump_int (di
, "-uid", DEBUG_TEMP_UID (t
));
522 if (TREE_CODE (t
) == PARM_DECL
)
523 dump_child ("argt", DECL_ARG_TYPE (t
));
525 dump_child ("init", DECL_INITIAL (t
));
526 dump_child ("size", DECL_SIZE (t
));
527 dump_int (di
, "algn", DECL_ALIGN (t
));
529 if (TREE_CODE (t
) == FIELD_DECL
)
531 if (DECL_FIELD_OFFSET (t
))
532 dump_child ("bpos", bit_position (t
));
534 else if (TREE_CODE (t
) == VAR_DECL
535 || TREE_CODE (t
) == PARM_DECL
)
537 dump_int (di
, "used", TREE_USED (t
));
538 if (DECL_REGISTER (t
))
539 dump_string_field (di
, "spec", "register");
544 dump_child ("args", DECL_ARGUMENTS (t
));
545 if (DECL_EXTERNAL (t
))
546 dump_string_field (di
, "body", "undefined");
548 dump_string_field (di
, "link", "extern");
550 dump_string_field (di
, "link", "static");
551 if (DECL_SAVED_TREE (t
) && !dump_flag (di
, TDF_SLIM
, t
))
552 dump_child ("body", DECL_SAVED_TREE (t
));
556 if (TREE_INT_CST_HIGH (t
))
557 dump_int (di
, "high", TREE_INT_CST_HIGH (t
));
558 dump_int (di
, "low", TREE_INT_CST_LOW (t
));
562 fprintf (di
->stream
, "strg: %-7s ", TREE_STRING_POINTER (t
));
563 dump_int (di
, "lngt", TREE_STRING_LENGTH (t
));
567 dump_real (di
, "valu", TREE_REAL_CST_PTR (t
));
571 dump_fixed (di
, "valu", TREE_FIXED_CST_PTR (t
));
577 case CLEANUP_POINT_EXPR
:
581 /* These nodes are unary, but do not have code class `1'. */
582 dump_child ("op 0", TREE_OPERAND (t
, 0));
585 case TRUTH_ANDIF_EXPR
:
586 case TRUTH_ORIF_EXPR
:
590 case PREDECREMENT_EXPR
:
591 case PREINCREMENT_EXPR
:
592 case POSTDECREMENT_EXPR
:
593 case POSTINCREMENT_EXPR
:
594 /* These nodes are binary, but do not have code class `2'. */
595 dump_child ("op 0", TREE_OPERAND (t
, 0));
596 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
},
829 {"all", ~(TDF_RAW
| TDF_SLIM
| TDF_LINENO
| TDF_TREE
| TDF_RTL
| TDF_IPA
830 | TDF_STMTADDR
| TDF_GRAPH
| TDF_DIAGNOSTIC
| TDF_VERBOSE
831 | TDF_RHS_ONLY
| TDF_NOUID
| TDF_ENUMERATE_LOCALS
| TDF_SCEV
837 dump_register (const char *suffix
, const char *swtch
, const char *glob
,
840 static int next_dump
= FIRST_AUTO_NUMBERED_DUMP
;
841 int num
= next_dump
++;
843 size_t count
= extra_dump_files_in_use
++;
845 if (count
>= extra_dump_files_alloced
)
847 if (extra_dump_files_alloced
== 0)
848 extra_dump_files_alloced
= 32;
850 extra_dump_files_alloced
*= 2;
851 extra_dump_files
= XRESIZEVEC (struct dump_file_info
,
853 extra_dump_files_alloced
);
856 memset (&extra_dump_files
[count
], 0, sizeof (struct dump_file_info
));
857 extra_dump_files
[count
].suffix
= suffix
;
858 extra_dump_files
[count
].swtch
= swtch
;
859 extra_dump_files
[count
].glob
= glob
;
860 extra_dump_files
[count
].flags
= flags
;
861 extra_dump_files
[count
].num
= num
;
863 return count
+ TDI_end
;
867 /* Return the dump_file_info for the given phase. */
869 struct dump_file_info
*
870 get_dump_file_info (int phase
)
873 return &dump_files
[phase
];
874 else if ((size_t) (phase
- TDI_end
) >= extra_dump_files_in_use
)
877 return extra_dump_files
+ (phase
- TDI_end
);
881 /* Return the name of the dump file for the given phase.
882 If the dump is not enabled, returns NULL. */
885 get_dump_file_name (int phase
)
888 struct dump_file_info
*dfi
;
890 if (phase
== TDI_none
)
893 dfi
= get_dump_file_info (phase
);
902 if (dfi
->flags
& TDF_TREE
)
904 else if (dfi
->flags
& TDF_IPA
)
909 if (snprintf (dump_id
, sizeof (dump_id
), ".%03d%c", dfi
->num
, suffix
) < 0)
913 return concat (dump_base_name
, dump_id
, dfi
->suffix
, NULL
);
916 /* Begin a tree dump for PHASE. Stores any user supplied flag in
917 *FLAG_PTR and returns a stream to write to. If the dump is not
918 enabled, returns NULL.
919 Multiple calls will reopen and append to the dump file. */
922 dump_begin (int phase
, int *flag_ptr
)
925 struct dump_file_info
*dfi
;
928 if (phase
== TDI_none
|| !dump_enabled_p (phase
))
931 name
= get_dump_file_name (phase
);
932 dfi
= get_dump_file_info (phase
);
933 stream
= fopen (name
, dfi
->state
< 0 ? "w" : "a");
935 error ("could not open dump file %qs: %m", name
);
941 *flag_ptr
= dfi
->flags
;
946 /* Returns nonzero if tree dump PHASE is enabled. If PHASE is
947 TDI_tree_all, return nonzero if any dump is enabled. */
950 dump_enabled_p (int phase
)
952 if (phase
== TDI_tree_all
)
955 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
956 if (dump_files
[i
].state
)
958 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
959 if (extra_dump_files
[i
].state
)
965 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
970 /* Returns nonzero if tree dump PHASE has been initialized. */
973 dump_initialized_p (int phase
)
975 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
976 return dfi
->state
> 0;
979 /* Returns the switch name of PHASE. */
982 dump_flag_name (int phase
)
984 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
988 /* Finish a tree dump for PHASE. STREAM is the stream created by
992 dump_end (int phase ATTRIBUTE_UNUSED
, FILE *stream
)
997 /* Enable all tree dumps. Return number of enabled tree dumps. */
1000 dump_enable_all (int flags
)
1002 int ir_dump_type
= (flags
& (TDF_TREE
| TDF_RTL
| TDF_IPA
));
1006 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1007 if ((dump_files
[i
].flags
& ir_dump_type
))
1009 dump_files
[i
].state
= -1;
1010 dump_files
[i
].flags
|= flags
;
1014 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1015 if ((extra_dump_files
[i
].flags
& ir_dump_type
))
1017 extra_dump_files
[i
].state
= -1;
1018 extra_dump_files
[i
].flags
|= flags
;
1025 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1026 relevant details in the dump_files array. */
1029 dump_switch_p_1 (const char *arg
, struct dump_file_info
*dfi
, bool doglob
)
1031 const char *option_value
;
1035 if (doglob
&& !dfi
->glob
)
1038 option_value
= skip_leading_substring (arg
, doglob
? dfi
->glob
: dfi
->swtch
);
1042 if (*option_value
&& *option_value
!= '-')
1050 const struct dump_option_value_info
*option_ptr
;
1051 const char *end_ptr
;
1056 end_ptr
= strchr (ptr
, '-');
1058 end_ptr
= ptr
+ strlen (ptr
);
1059 length
= end_ptr
- ptr
;
1061 for (option_ptr
= dump_options
; option_ptr
->name
; option_ptr
++)
1062 if (strlen (option_ptr
->name
) == length
1063 && !memcmp (option_ptr
->name
, ptr
, length
))
1065 flags
|= option_ptr
->value
;
1068 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1069 length
, ptr
, dfi
->swtch
);
1075 dfi
->flags
|= flags
;
1077 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1079 if (dfi
->suffix
== NULL
)
1080 dump_enable_all (dfi
->flags
);
1086 dump_switch_p (const char *arg
)
1091 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1092 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], false);
1094 /* Don't glob if we got a hit already */
1096 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1097 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], true);
1099 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1100 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], false);
1103 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1104 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], true);
1110 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1113 dump_function (int phase
, tree fn
)
1118 stream
= dump_begin (phase
, &flags
);
1121 dump_function_to_file (fn
, stream
, flags
);
1122 dump_end (phase
, stream
);
1127 enable_rtl_dump_file (void)
1129 return dump_enable_all (TDF_RTL
| TDF_DETAILS
| TDF_BLOCKS
) > 0;