1 /* Tree-dumping functionality for intermediate representation.
2 Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007
3 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 "diagnostic.h"
30 #include "tree-dump.h"
31 #include "tree-pass.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
36 static unsigned int queue (dump_info_p
, tree
, int);
37 static void dump_index (dump_info_p
, unsigned int);
38 static void dequeue_and_dump (dump_info_p
);
39 static void dump_new_line (dump_info_p
);
40 static void dump_maybe_newline (dump_info_p
);
41 static int dump_enable_all (int, int);
43 /* Add T to the end of the queue of nodes to dump. Returns the index
47 queue (dump_info_p di
, tree t
, int flags
)
53 /* Assign the next available index to T. */
56 /* Obtain a new queue node. */
60 di
->free_list
= dq
->next
;
63 dq
= XNEW (struct dump_queue
);
65 /* Create a new entry in the splay-tree. */
66 dni
= XNEW (struct dump_node_info
);
68 dni
->binfo_p
= ((flags
& DUMP_BINFO
) != 0);
69 dq
->node
= splay_tree_insert (di
->nodes
, (splay_tree_key
) t
,
70 (splay_tree_value
) dni
);
72 /* Add it to the end of the queue. */
77 di
->queue_end
->next
= dq
;
80 /* Return the index. */
85 dump_index (dump_info_p di
, unsigned int index
)
87 fprintf (di
->stream
, "@%-6u ", index
);
91 /* If T has not already been output, queue it for subsequent output.
92 FIELD is a string to print before printing the index. Then, the
93 index of T is printed. */
96 queue_and_dump_index (dump_info_p di
, const char *field
, tree t
, int flags
)
101 /* If there's no node, just return. This makes for fewer checks in
106 /* See if we've already queued or dumped this node. */
107 n
= splay_tree_lookup (di
->nodes
, (splay_tree_key
) t
);
109 index
= ((dump_node_info_p
) n
->value
)->index
;
111 /* If we haven't, add it to the queue. */
112 index
= queue (di
, t
, flags
);
114 /* Print the index of the node. */
115 dump_maybe_newline (di
);
116 fprintf (di
->stream
, "%-4s: ", field
);
118 dump_index (di
, index
);
121 /* Dump the type of T. */
124 queue_and_dump_type (dump_info_p di
, tree t
)
126 queue_and_dump_index (di
, "type", TREE_TYPE (t
), DUMP_NONE
);
129 /* Dump column control */
130 #define SOL_COLUMN 25 /* Start of line column. */
131 #define EOL_COLUMN 55 /* End of line column. */
132 #define COLUMN_ALIGNMENT 15 /* Alignment. */
134 /* Insert a new line in the dump output, and indent to an appropriate
135 place to start printing more fields. */
138 dump_new_line (dump_info_p di
)
140 fprintf (di
->stream
, "\n%*s", SOL_COLUMN
, "");
141 di
->column
= SOL_COLUMN
;
144 /* If necessary, insert a new line. */
147 dump_maybe_newline (dump_info_p di
)
151 /* See if we need a new line. */
152 if (di
->column
> EOL_COLUMN
)
154 /* See if we need any padding. */
155 else if ((extra
= (di
->column
- SOL_COLUMN
) % COLUMN_ALIGNMENT
) != 0)
157 fprintf (di
->stream
, "%*s", COLUMN_ALIGNMENT
- extra
, "");
158 di
->column
+= COLUMN_ALIGNMENT
- extra
;
162 /* Dump pointer PTR using FIELD to identify it. */
165 dump_pointer (dump_info_p di
, const char *field
, void *ptr
)
167 dump_maybe_newline (di
);
168 fprintf (di
->stream
, "%-4s: %-8lx ", field
, (long) ptr
);
172 /* Dump integer I using FIELD to identify it. */
175 dump_int (dump_info_p di
, const char *field
, int i
)
177 dump_maybe_newline (di
);
178 fprintf (di
->stream
, "%-4s: %-7d ", field
, i
);
182 /* Dump the floating point value R, using FIELD to identify it. */
185 dump_real (dump_info_p di
, const char *field
, const REAL_VALUE_TYPE
*r
)
188 real_to_decimal (buf
, r
, sizeof (buf
), 0, true);
189 dump_maybe_newline (di
);
190 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
191 di
->column
+= strlen (buf
) + 7;
195 /* Dump the string S. */
198 dump_string (dump_info_p di
, const char *string
)
200 dump_maybe_newline (di
);
201 fprintf (di
->stream
, "%-13s ", string
);
202 if (strlen (string
) > 13)
203 di
->column
+= strlen (string
) + 1;
208 /* Dump the string field S. */
211 dump_string_field (dump_info_p di
, const char *field
, const char *string
)
213 dump_maybe_newline (di
);
214 fprintf (di
->stream
, "%-4s: %-7s ", field
, string
);
215 if (strlen (string
) > 7)
216 di
->column
+= 6 + strlen (string
) + 1;
221 /* Dump the next node in the queue. */
224 dequeue_and_dump (dump_info_p di
)
228 dump_node_info_p dni
;
232 enum tree_code_class code_class
;
233 const char* code_name
;
235 /* Get the next node from the queue. */
239 dni
= (dump_node_info_p
) stn
->value
;
242 /* Remove the node from the queue, and put it on the free list. */
243 di
->queue
= dq
->next
;
246 dq
->next
= di
->free_list
;
249 /* Print the node index. */
250 dump_index (di
, index
);
251 /* And the type of node this is. */
255 code_name
= tree_code_name
[(int) TREE_CODE (t
)];
256 fprintf (di
->stream
, "%-16s ", code_name
);
259 /* Figure out what kind of node this is. */
260 code
= TREE_CODE (t
);
261 code_class
= TREE_CODE_CLASS (code
);
263 /* Although BINFOs are TREE_VECs, we dump them specially so as to be
269 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (t
);
271 dump_child ("type", BINFO_TYPE (t
));
273 if (BINFO_VIRTUAL_P (t
))
274 dump_string_field (di
, "spec", "virt");
276 dump_int (di
, "bases", BINFO_N_BASE_BINFOS (t
));
277 for (ix
= 0; BINFO_BASE_ITERATE (t
, ix
, base
); ix
++)
279 tree access
= (accesses
? VEC_index (tree
, accesses
, ix
)
280 : access_public_node
);
281 const char *string
= NULL
;
283 if (access
== access_public_node
)
285 else if (access
== access_protected_node
)
287 else if (access
== access_private_node
)
292 dump_string_field (di
, "accs", string
);
293 queue_and_dump_index (di
, "binf", base
, DUMP_BINFO
);
299 /* We can knock off a bunch of expression nodes in exactly the same
301 if (IS_EXPR_CODE_CLASS (code_class
))
303 /* If we're dumping children, dump them now. */
304 queue_and_dump_type (di
, t
);
309 dump_child ("op 0", TREE_OPERAND (t
, 0));
314 dump_child ("op 0", TREE_OPERAND (t
, 0));
315 dump_child ("op 1", TREE_OPERAND (t
, 1));
321 /* These nodes are handled explicitly below. */
330 expanded_location xloc
;
331 /* All declarations have names. */
333 dump_child ("name", DECL_NAME (t
));
334 if (DECL_ASSEMBLER_NAME_SET_P (t
)
335 && DECL_ASSEMBLER_NAME (t
) != DECL_NAME (t
))
336 dump_child ("mngl", DECL_ASSEMBLER_NAME (t
));
337 if (DECL_ABSTRACT_ORIGIN (t
))
338 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t
));
340 queue_and_dump_type (di
, t
);
341 dump_child ("scpe", DECL_CONTEXT (t
));
342 /* And a source position. */
343 xloc
= expand_location (DECL_SOURCE_LOCATION (t
));
346 const char *filename
= strrchr (xloc
.file
, '/');
348 filename
= xloc
.file
;
350 /* Skip the slash. */
353 dump_maybe_newline (di
);
354 fprintf (di
->stream
, "srcp: %s:%-6d ", filename
,
356 di
->column
+= 6 + strlen (filename
) + 8;
358 /* And any declaration can be compiler-generated. */
359 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_COMMON
)
360 && DECL_ARTIFICIAL (t
))
361 dump_string_field (di
, "note", "artificial");
362 if (TREE_CHAIN (t
) && !dump_flag (di
, TDF_SLIM
, NULL
))
363 dump_child ("chan", TREE_CHAIN (t
));
365 else if (code_class
== tcc_type
)
367 /* All types have qualifiers. */
368 int quals
= lang_hooks
.tree_dump
.type_quals (t
);
370 if (quals
!= TYPE_UNQUALIFIED
)
372 fprintf (di
->stream
, "qual: %c%c%c ",
373 (quals
& TYPE_QUAL_CONST
) ? 'c' : ' ',
374 (quals
& TYPE_QUAL_VOLATILE
) ? 'v' : ' ',
375 (quals
& TYPE_QUAL_RESTRICT
) ? 'r' : ' ');
379 /* All types have associated declarations. */
380 dump_child ("name", TYPE_NAME (t
));
382 /* All types have a main variant. */
383 if (TYPE_MAIN_VARIANT (t
) != t
)
384 dump_child ("unql", TYPE_MAIN_VARIANT (t
));
387 dump_child ("size", TYPE_SIZE (t
));
389 /* All types have alignments. */
390 dump_int (di
, "algn", TYPE_ALIGN (t
));
392 else if (code_class
== tcc_constant
)
393 /* All constants can have types. */
394 queue_and_dump_type (di
, t
);
396 /* Give the language-specific code a chance to print something. If
397 it's completely taken care of things, don't bother printing
398 anything more ourselves. */
399 if (lang_hooks
.tree_dump
.dump_tree (di
, t
))
402 /* Now handle the various kinds of nodes. */
407 case IDENTIFIER_NODE
:
408 dump_string_field (di
, "strg", IDENTIFIER_POINTER (t
));
409 dump_int (di
, "lngt", IDENTIFIER_LENGTH (t
));
413 dump_child ("purp", TREE_PURPOSE (t
));
414 dump_child ("valu", TREE_VALUE (t
));
415 dump_child ("chan", TREE_CHAIN (t
));
420 tree_stmt_iterator it
;
421 for (i
= 0, it
= tsi_start (t
); !tsi_end_p (it
); tsi_next (&it
), i
++)
424 sprintf (buffer
, "%u", i
);
425 dump_child (buffer
, tsi_stmt (it
));
431 dump_int (di
, "lngt", TREE_VEC_LENGTH (t
));
432 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
435 sprintf (buffer
, "%u", i
);
436 dump_child (buffer
, TREE_VEC_ELT (t
, i
));
442 dump_int (di
, "prec", TYPE_PRECISION (t
));
443 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
444 dump_child ("min", TYPE_MIN_VALUE (t
));
445 dump_child ("max", TYPE_MAX_VALUE (t
));
447 if (code
== ENUMERAL_TYPE
)
448 dump_child ("csts", TYPE_VALUES (t
));
452 dump_int (di
, "prec", TYPE_PRECISION (t
));
456 dump_child ("ptd", TREE_TYPE (t
));
460 dump_child ("refd", TREE_TYPE (t
));
464 dump_child ("clas", TYPE_METHOD_BASETYPE (t
));
468 dump_child ("retn", TREE_TYPE (t
));
469 dump_child ("prms", TYPE_ARG_TYPES (t
));
473 dump_child ("elts", TREE_TYPE (t
));
474 dump_child ("domn", TYPE_DOMAIN (t
));
479 if (TREE_CODE (t
) == RECORD_TYPE
)
480 dump_string_field (di
, "tag", "struct");
482 dump_string_field (di
, "tag", "union");
484 dump_child ("flds", TYPE_FIELDS (t
));
485 dump_child ("fncs", TYPE_METHODS (t
));
486 queue_and_dump_index (di
, "binf", TYPE_BINFO (t
),
491 dump_child ("cnst", DECL_INITIAL (t
));
494 case SYMBOL_MEMORY_TAG
:
495 case NAME_MEMORY_TAG
:
496 case STRUCT_FIELD_TAG
:
503 if (TREE_CODE (t
) == PARM_DECL
)
504 dump_child ("argt", DECL_ARG_TYPE (t
));
506 dump_child ("init", DECL_INITIAL (t
));
507 dump_child ("size", DECL_SIZE (t
));
508 dump_int (di
, "algn", DECL_ALIGN (t
));
510 if (TREE_CODE (t
) == FIELD_DECL
)
512 if (DECL_FIELD_OFFSET (t
))
513 dump_child ("bpos", bit_position (t
));
515 else if (TREE_CODE (t
) == VAR_DECL
516 || TREE_CODE (t
) == PARM_DECL
)
518 dump_int (di
, "used", TREE_USED (t
));
519 if (DECL_REGISTER (t
))
520 dump_string_field (di
, "spec", "register");
525 dump_child ("args", DECL_ARGUMENTS (t
));
526 if (DECL_EXTERNAL (t
))
527 dump_string_field (di
, "body", "undefined");
529 dump_string_field (di
, "link", "extern");
531 dump_string_field (di
, "link", "static");
532 if (DECL_LANG_SPECIFIC (t
) && !dump_flag (di
, TDF_SLIM
, t
))
533 dump_child ("body", DECL_SAVED_TREE (t
));
537 if (TREE_INT_CST_HIGH (t
))
538 dump_int (di
, "high", TREE_INT_CST_HIGH (t
));
539 dump_int (di
, "low", TREE_INT_CST_LOW (t
));
543 fprintf (di
->stream
, "strg: %-7s ", TREE_STRING_POINTER (t
));
544 dump_int (di
, "lngt", TREE_STRING_LENGTH (t
));
548 dump_real (di
, "valu", TREE_REAL_CST_PTR (t
));
554 case ALIGN_INDIRECT_REF
:
555 case MISALIGNED_INDIRECT_REF
:
556 case CLEANUP_POINT_EXPR
:
560 /* These nodes are unary, but do not have code class `1'. */
561 dump_child ("op 0", TREE_OPERAND (t
, 0));
564 case TRUTH_ANDIF_EXPR
:
565 case TRUTH_ORIF_EXPR
:
569 case PREDECREMENT_EXPR
:
570 case PREINCREMENT_EXPR
:
571 case POSTDECREMENT_EXPR
:
572 case POSTINCREMENT_EXPR
:
573 /* These nodes are binary, but do not have code class `2'. */
574 dump_child ("op 0", TREE_OPERAND (t
, 0));
575 dump_child ("op 1", TREE_OPERAND (t
, 1));
579 dump_child ("op 0", TREE_OPERAND (t
, 0));
580 dump_child ("op 1", TREE_OPERAND (t
, 1));
581 dump_child ("op 2", TREE_OPERAND (t
, 2));
585 case ARRAY_RANGE_REF
:
586 dump_child ("op 0", TREE_OPERAND (t
, 0));
587 dump_child ("op 1", TREE_OPERAND (t
, 1));
588 dump_child ("op 2", TREE_OPERAND (t
, 2));
589 dump_child ("op 3", TREE_OPERAND (t
, 3));
593 dump_child ("op 0", TREE_OPERAND (t
, 0));
594 dump_child ("op 1", TREE_OPERAND (t
, 1));
595 dump_child ("op 2", TREE_OPERAND (t
, 2));
598 case TRY_FINALLY_EXPR
:
599 dump_child ("op 0", TREE_OPERAND (t
, 0));
600 dump_child ("op 1", TREE_OPERAND (t
, 1));
604 dump_child ("fn", TREE_OPERAND (t
, 0));
605 dump_child ("args", TREE_OPERAND (t
, 1));
610 unsigned HOST_WIDE_INT cnt
;
612 dump_int (di
, "lngt", VEC_length (constructor_elt
,
613 CONSTRUCTOR_ELTS (t
)));
614 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), cnt
, index
, value
)
616 dump_child ("idx", index
);
617 dump_child ("val", value
);
623 dump_child ("vars", TREE_OPERAND (t
, 0));
624 dump_child ("body", TREE_OPERAND (t
, 1));
628 dump_child ("body", TREE_OPERAND (t
, 0));
632 dump_child ("cond", TREE_OPERAND (t
, 0));
636 dump_child ("expr", TREE_OPERAND (t
, 0));
640 dump_child ("decl", TREE_OPERAND (t
, 0));
641 dump_child ("init", TREE_OPERAND (t
, 1));
642 dump_child ("clnp", TREE_OPERAND (t
, 2));
643 /* There really are two possible places the initializer can be.
644 After RTL expansion, the second operand is moved to the
645 position of the fourth operand, and the second operand
647 dump_child ("init", TREE_OPERAND (t
, 3));
650 case CASE_LABEL_EXPR
:
651 dump_child ("name", CASE_LABEL (t
));
653 dump_child ("low ", CASE_LOW (t
));
655 dump_child ("high", CASE_HIGH (t
));
660 dump_child ("name", TREE_OPERAND (t
,0));
663 dump_child ("labl", TREE_OPERAND (t
, 0));
666 dump_child ("cond", TREE_OPERAND (t
, 0));
667 dump_child ("body", TREE_OPERAND (t
, 1));
668 if (TREE_OPERAND (t
, 2))
670 dump_child ("labl", TREE_OPERAND (t
,2));
676 fprintf (di
->stream
, "%s\n", omp_clause_code_name
[OMP_CLAUSE_CODE (t
)]);
677 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
678 dump_child ("op: ", OMP_CLAUSE_OPERAND (t
, i
));
682 /* There are no additional fields to print. */
687 if (dump_flag (di
, TDF_ADDRESS
, NULL
))
688 dump_pointer (di
, "addr", (void *)t
);
690 /* Terminate the line. */
691 fprintf (di
->stream
, "\n");
694 /* Return nonzero if FLAG has been specified for the dump, and NODE
695 is not the root node of the dump. */
697 int dump_flag (dump_info_p di
, int flag
, tree node
)
699 return (di
->flags
& flag
) && (node
!= di
->node
);
702 /* Dump T, and all its children, on STREAM. */
705 dump_node (tree t
, int flags
, FILE *stream
)
709 dump_queue_p next_dq
;
711 /* Initialize the dump-information structure. */
720 di
.nodes
= splay_tree_new (splay_tree_compare_pointers
, 0,
721 (splay_tree_delete_value_fn
) &free
);
723 /* Queue up the first node. */
724 queue (&di
, t
, DUMP_NONE
);
726 /* Until the queue is empty, keep dumping nodes. */
728 dequeue_and_dump (&di
);
731 for (dq
= di
.free_list
; dq
; dq
= next_dq
)
736 splay_tree_delete (di
.nodes
);
740 /* Table of tree dump switches. This must be consistent with the
741 TREE_DUMP_INDEX enumeration in tree.h. */
742 static struct dump_file_info dump_files
[TDI_end
] =
744 {NULL
, NULL
, NULL
, 0, 0, 0, 0},
745 {".cgraph", "ipa-cgraph", NULL
, TDF_IPA
, 0, 0, 0},
746 {".tu", "translation-unit", NULL
, TDF_TREE
, 0, 1, 0},
747 {".class", "class-hierarchy", NULL
, TDF_TREE
, 0, 2, 0},
748 {".original", "tree-original", NULL
, TDF_TREE
, 0, 3, 0},
749 {".gimple", "tree-gimple", NULL
, TDF_TREE
, 0, 4, 0},
750 {".nested", "tree-nested", NULL
, TDF_TREE
, 0, 5, 0},
751 {".inlined", "tree-inlined", NULL
, TDF_TREE
, 0, 6, 0},
752 {".vcg", "tree-vcg", NULL
, TDF_TREE
, 0, 7, 0},
753 #define FIRST_AUTO_NUMBERED_DUMP 8
755 {NULL
, "tree-all", NULL
, TDF_TREE
, 0, 0, 0},
756 {NULL
, "rtl-all", NULL
, TDF_RTL
, 0, 0, 0},
757 {NULL
, "ipa-all", NULL
, TDF_IPA
, 0, 0, 0},
760 /* Dynamically registered tree dump files and switches. */
761 static struct dump_file_info
*extra_dump_files
;
762 static size_t extra_dump_files_in_use
;
763 static size_t extra_dump_files_alloced
;
765 /* Define a name->number mapping for a dump flag value. */
766 struct dump_option_value_info
768 const char *const name
; /* the name of the value */
769 const int value
; /* the value of the name */
772 /* Table of dump options. This must be consistent with the TDF_* flags
774 static const struct dump_option_value_info dump_options
[] =
776 {"address", TDF_ADDRESS
},
779 {"details", TDF_DETAILS
},
780 {"stats", TDF_STATS
},
781 {"blocks", TDF_BLOCKS
},
783 {"lineno", TDF_LINENO
},
785 {"stmtaddr", TDF_STMTADDR
},
786 {"all", ~(TDF_RAW
| TDF_SLIM
| TDF_LINENO
| TDF_TREE
| TDF_RTL
| TDF_IPA
787 | TDF_STMTADDR
| TDF_GRAPH
)},
792 dump_register (const char *suffix
, const char *swtch
, const char *glob
,
793 int flags
, int letter
)
795 static int next_dump
= FIRST_AUTO_NUMBERED_DUMP
;
796 int num
= next_dump
++;
798 size_t this = extra_dump_files_in_use
++;
800 if (this >= extra_dump_files_alloced
)
802 if (extra_dump_files_alloced
== 0)
803 extra_dump_files_alloced
= 32;
805 extra_dump_files_alloced
*= 2;
806 extra_dump_files
= xrealloc (extra_dump_files
,
807 sizeof (struct dump_file_info
)
808 * extra_dump_files_alloced
);
811 memset (&extra_dump_files
[this], 0, sizeof (struct dump_file_info
));
812 extra_dump_files
[this].suffix
= suffix
;
813 extra_dump_files
[this].swtch
= swtch
;
814 extra_dump_files
[this].glob
= glob
;
815 extra_dump_files
[this].flags
= flags
;
816 extra_dump_files
[this].num
= num
;
817 extra_dump_files
[this].letter
= letter
;
819 return this + TDI_end
;
823 /* Return the dump_file_info for the given phase. */
825 struct dump_file_info
*
826 get_dump_file_info (enum tree_dump_index phase
)
829 return &dump_files
[phase
];
830 else if (phase
- TDI_end
>= extra_dump_files_in_use
)
833 return extra_dump_files
+ (phase
- TDI_end
);
837 /* Return the name of the dump file for the given phase.
838 If the dump is not enabled, returns NULL. */
841 get_dump_file_name (enum tree_dump_index phase
)
844 struct dump_file_info
*dfi
;
846 if (phase
== TDI_none
)
849 dfi
= get_dump_file_info (phase
);
858 if (dfi
->flags
& TDF_TREE
)
860 else if (dfi
->flags
& TDF_IPA
)
865 if (snprintf (dump_id
, sizeof (dump_id
), ".%03d%c", dfi
->num
, suffix
) < 0)
869 return concat (dump_base_name
, dump_id
, dfi
->suffix
, NULL
);
872 /* Begin a tree dump for PHASE. Stores any user supplied flag in
873 *FLAG_PTR and returns a stream to write to. If the dump is not
874 enabled, returns NULL.
875 Multiple calls will reopen and append to the dump file. */
878 dump_begin (enum tree_dump_index phase
, int *flag_ptr
)
881 struct dump_file_info
*dfi
;
884 if (phase
== TDI_none
|| !dump_enabled_p (phase
))
887 name
= get_dump_file_name (phase
);
888 dfi
= get_dump_file_info (phase
);
889 stream
= fopen (name
, dfi
->state
< 0 ? "w" : "a");
891 error ("could not open dump file %qs: %s", name
, strerror (errno
));
897 *flag_ptr
= dfi
->flags
;
902 /* Returns nonzero if tree dump PHASE is enabled. If PHASE is
903 TDI_tree_all, return nonzero if any dump is enabled. */
906 dump_enabled_p (enum tree_dump_index phase
)
908 if (phase
== TDI_tree_all
)
911 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
912 if (dump_files
[i
].state
)
914 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
915 if (extra_dump_files
[i
].state
)
921 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
926 /* Returns nonzero if tree dump PHASE has been initialized. */
929 dump_initialized_p (enum tree_dump_index phase
)
931 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
932 return dfi
->state
> 0;
935 /* Returns the switch name of PHASE. */
938 dump_flag_name (enum tree_dump_index phase
)
940 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
944 /* Finish a tree dump for PHASE. STREAM is the stream created by
948 dump_end (enum tree_dump_index phase ATTRIBUTE_UNUSED
, FILE *stream
)
953 /* Enable all tree dumps. Return number of enabled tree dumps. */
956 dump_enable_all (int flags
, int letter
)
958 int ir_type
= (flags
& (TDF_TREE
| TDF_RTL
| TDF_IPA
));
962 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
963 if ((dump_files
[i
].flags
& ir_type
)
964 && (letter
== 0 || letter
== dump_files
[i
].letter
))
966 dump_files
[i
].state
= -1;
967 dump_files
[i
].flags
|= flags
;
971 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
972 if ((extra_dump_files
[i
].flags
& ir_type
)
973 && (letter
== 0 || letter
== extra_dump_files
[i
].letter
))
975 extra_dump_files
[i
].state
= -1;
976 extra_dump_files
[i
].flags
|= flags
;
983 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
984 relevant details in the dump_files array. */
987 dump_switch_p_1 (const char *arg
, struct dump_file_info
*dfi
, bool doglob
)
989 const char *option_value
;
993 if (doglob
&& !dfi
->glob
)
996 option_value
= skip_leading_substring (arg
, doglob
? dfi
->glob
: dfi
->swtch
);
1005 const struct dump_option_value_info
*option_ptr
;
1006 const char *end_ptr
;
1011 end_ptr
= strchr (ptr
, '-');
1013 end_ptr
= ptr
+ strlen (ptr
);
1014 length
= end_ptr
- ptr
;
1016 for (option_ptr
= dump_options
; option_ptr
->name
; option_ptr
++)
1017 if (strlen (option_ptr
->name
) == length
1018 && !memcmp (option_ptr
->name
, ptr
, length
))
1020 flags
|= option_ptr
->value
;
1023 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1024 length
, ptr
, dfi
->swtch
);
1030 dfi
->flags
|= flags
;
1032 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1034 if (dfi
->suffix
== NULL
)
1035 dump_enable_all (dfi
->flags
, 0);
1041 dump_switch_p (const char *arg
)
1046 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1047 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], false);
1049 /* Don't glob if we got a hit already */
1051 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1052 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], true);
1054 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1055 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], false);
1058 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1059 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], true);
1065 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1068 dump_function (enum tree_dump_index phase
, tree fn
)
1073 stream
= dump_begin (phase
, &flags
);
1076 dump_function_to_file (fn
, stream
, flags
);
1077 dump_end (phase
, stream
);
1082 enable_rtl_dump_file (int letter
)
1087 return dump_enable_all (TDF_RTL
| TDF_DETAILS
| TDF_BLOCKS
, letter
) > 0;