1 /* Tree-dumping functionality for intermediate representation.
2 Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005
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 2, 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 COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "coretypes.h"
28 #include "splay-tree.h"
29 #include "diagnostic.h"
31 #include "tree-dump.h"
32 #include "tree-pass.h"
33 #include "langhooks.h"
34 #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 = xmalloc (sizeof (struct dump_queue));
65 /* Create a new entry in the splay-tree. */
66 dni = xmalloc (sizeof (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 string S. */
185 dump_string (dump_info_p di, const char *string)
187 dump_maybe_newline (di);
188 fprintf (di->stream, "%-13s ", string);
189 if (strlen (string) > 13)
190 di->column += strlen (string) + 1;
195 /* Dump the string field S. */
198 dump_string_field (dump_info_p di, const char *field, const char *string)
200 dump_maybe_newline (di);
201 fprintf (di->stream, "%-4s: %-7s ", field, string);
202 if (strlen (string) > 7)
203 di->column += 6 + strlen (string) + 1;
208 /* Dump the next node in the queue. */
211 dequeue_and_dump (dump_info_p di)
215 dump_node_info_p dni;
219 enum tree_code_class code_class;
220 const char* code_name;
222 /* Get the next node from the queue. */
226 dni = (dump_node_info_p) stn->value;
229 /* Remove the node from the queue, and put it on the free list. */
230 di->queue = dq->next;
233 dq->next = di->free_list;
236 /* Print the node index. */
237 dump_index (di, index);
238 /* And the type of node this is. */
242 code_name = tree_code_name[(int) TREE_CODE (t)];
243 fprintf (di->stream, "%-16s ", code_name);
246 /* Figure out what kind of node this is. */
247 code = TREE_CODE (t);
248 code_class = TREE_CODE_CLASS (code);
250 /* Although BINFOs are TREE_VECs, we dump them specially so as to be
256 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
258 dump_child ("type", BINFO_TYPE (t));
260 if (BINFO_VIRTUAL_P (t))
261 dump_string_field (di, "spec", "virt");
263 dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
264 for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
266 tree access = (accesses ? VEC_index (tree, accesses, ix)
267 : access_public_node);
268 const char *string = NULL;
270 if (access == access_public_node)
272 else if (access == access_protected_node)
274 else if (access == access_private_node)
279 dump_string_field (di, "accs", string);
280 queue_and_dump_index (di, "binf", base, DUMP_BINFO);
286 /* We can knock off a bunch of expression nodes in exactly the same
288 if (IS_EXPR_CODE_CLASS (code_class))
290 /* If we're dumping children, dump them now. */
291 queue_and_dump_type (di, t);
296 dump_child ("op 0", TREE_OPERAND (t, 0));
301 dump_child ("op 0", TREE_OPERAND (t, 0));
302 dump_child ("op 1", TREE_OPERAND (t, 1));
308 /* These nodes are handled explicitly below. */
317 expanded_location xloc;
318 /* All declarations have names. */
320 dump_child ("name", DECL_NAME (t));
321 if (DECL_ASSEMBLER_NAME_SET_P (t)
322 && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
323 dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
324 if (DECL_ABSTRACT_ORIGIN (t))
325 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
327 queue_and_dump_type (di, t);
328 dump_child ("scpe", DECL_CONTEXT (t));
329 /* And a source position. */
330 xloc = expand_location (DECL_SOURCE_LOCATION (t));
333 const char *filename = strrchr (xloc.file, '/');
335 filename = xloc.file;
337 /* Skip the slash. */
340 dump_maybe_newline (di);
341 fprintf (di->stream, "srcp: %s:%-6d ", filename,
343 di->column += 6 + strlen (filename) + 8;
345 /* And any declaration can be compiler-generated. */
346 if (DECL_ARTIFICIAL (t))
347 dump_string_field (di, "note", "artificial");
348 if (TREE_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
349 dump_child ("chan", TREE_CHAIN (t));
351 else if (code_class == tcc_type)
353 /* All types have qualifiers. */
354 int quals = lang_hooks.tree_dump.type_quals (t);
356 if (quals != TYPE_UNQUALIFIED)
358 fprintf (di->stream, "qual: %c%c%c ",
359 (quals & TYPE_QUAL_CONST) ? 'c' : ' ',
360 (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
361 (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
365 /* All types have associated declarations. */
366 dump_child ("name", TYPE_NAME (t));
368 /* All types have a main variant. */
369 if (TYPE_MAIN_VARIANT (t) != t)
370 dump_child ("unql", TYPE_MAIN_VARIANT (t));
373 dump_child ("size", TYPE_SIZE (t));
375 /* All types have alignments. */
376 dump_int (di, "algn", TYPE_ALIGN (t));
378 else if (code_class == tcc_constant)
379 /* All constants can have types. */
380 queue_and_dump_type (di, t);
382 /* Give the language-specific code a chance to print something. If
383 it's completely taken care of things, don't bother printing
384 anything more ourselves. */
385 if (lang_hooks.tree_dump.dump_tree (di, t))
388 /* Now handle the various kinds of nodes. */
393 case IDENTIFIER_NODE:
394 dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
395 dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
399 dump_child ("purp", TREE_PURPOSE (t));
400 dump_child ("valu", TREE_VALUE (t));
401 dump_child ("chan", TREE_CHAIN (t));
406 tree_stmt_iterator it;
407 for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
410 sprintf (buffer, "%u", i);
411 dump_child (buffer, tsi_stmt (it));
417 dump_int (di, "lngt", TREE_VEC_LENGTH (t));
418 for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
421 sprintf (buffer, "%u", i);
422 dump_child (buffer, TREE_VEC_ELT (t, i));
428 dump_int (di, "prec", TYPE_PRECISION (t));
429 dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
430 dump_child ("min", TYPE_MIN_VALUE (t));
431 dump_child ("max", TYPE_MAX_VALUE (t));
433 if (code == ENUMERAL_TYPE)
434 dump_child ("csts", TYPE_VALUES (t));
438 dump_int (di, "prec", TYPE_PRECISION (t));
442 dump_child ("ptd", TREE_TYPE (t));
446 dump_child ("refd", TREE_TYPE (t));
450 dump_child ("clas", TYPE_METHOD_BASETYPE (t));
454 dump_child ("retn", TREE_TYPE (t));
455 dump_child ("prms", TYPE_ARG_TYPES (t));
459 dump_child ("elts", TREE_TYPE (t));
460 dump_child ("domn", TYPE_DOMAIN (t));
465 if (TREE_CODE (t) == RECORD_TYPE)
466 dump_string_field (di, "tag", "struct");
468 dump_string_field (di, "tag", "union");
470 dump_child ("flds", TYPE_FIELDS (t));
471 dump_child ("fncs", TYPE_METHODS (t));
472 queue_and_dump_index (di, "binf", TYPE_BINFO (t),
477 dump_child ("cnst", DECL_INITIAL (t));
484 if (TREE_CODE (t) == PARM_DECL)
485 dump_child ("argt", DECL_ARG_TYPE (t));
487 dump_child ("init", DECL_INITIAL (t));
488 dump_child ("size", DECL_SIZE (t));
489 dump_int (di, "algn", DECL_ALIGN (t));
491 if (TREE_CODE (t) == FIELD_DECL)
493 if (DECL_FIELD_OFFSET (t))
494 dump_child ("bpos", bit_position (t));
496 else if (TREE_CODE (t) == VAR_DECL
497 || TREE_CODE (t) == PARM_DECL)
499 dump_int (di, "used", TREE_USED (t));
500 if (DECL_REGISTER (t))
501 dump_string_field (di, "spec", "register");
506 dump_child ("args", DECL_ARGUMENTS (t));
507 if (DECL_EXTERNAL (t))
508 dump_string_field (di, "body", "undefined");
510 dump_string_field (di, "link", "extern");
512 dump_string_field (di, "link", "static");
513 if (DECL_LANG_SPECIFIC (t) && !dump_flag (di, TDF_SLIM, t))
514 dump_child ("body", DECL_SAVED_TREE (t));
518 if (TREE_INT_CST_HIGH (t))
519 dump_int (di, "high", TREE_INT_CST_HIGH (t));
520 dump_int (di, "low", TREE_INT_CST_LOW (t));
524 fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
525 dump_int (di, "lngt", TREE_STRING_LENGTH (t));
531 case ALIGN_INDIRECT_REF:
532 case MISALIGNED_INDIRECT_REF:
533 case CLEANUP_POINT_EXPR:
537 /* These nodes are unary, but do not have code class `1'. */
538 dump_child ("op 0", TREE_OPERAND (t, 0));
541 case TRUTH_ANDIF_EXPR:
542 case TRUTH_ORIF_EXPR:
546 case PREDECREMENT_EXPR:
547 case PREINCREMENT_EXPR:
548 case POSTDECREMENT_EXPR:
549 case POSTINCREMENT_EXPR:
550 /* These nodes are binary, but do not have code class `2'. */
551 dump_child ("op 0", TREE_OPERAND (t, 0));
552 dump_child ("op 1", TREE_OPERAND (t, 1));
556 dump_child ("op 0", TREE_OPERAND (t, 0));
557 dump_child ("op 1", TREE_OPERAND (t, 1));
558 dump_child ("op 2", TREE_OPERAND (t, 2));
562 case ARRAY_RANGE_REF:
563 dump_child ("op 0", TREE_OPERAND (t, 0));
564 dump_child ("op 1", TREE_OPERAND (t, 1));
565 dump_child ("op 2", TREE_OPERAND (t, 2));
566 dump_child ("op 3", TREE_OPERAND (t, 3));
570 dump_child ("op 0", TREE_OPERAND (t, 0));
571 dump_child ("op 1", TREE_OPERAND (t, 1));
572 dump_child ("op 2", TREE_OPERAND (t, 2));
575 case TRY_FINALLY_EXPR:
576 dump_child ("op 0", TREE_OPERAND (t, 0));
577 dump_child ("op 1", TREE_OPERAND (t, 1));
581 dump_child ("fn", TREE_OPERAND (t, 0));
582 dump_child ("args", TREE_OPERAND (t, 1));
586 dump_child ("elts", CONSTRUCTOR_ELTS (t));
590 dump_child ("vars", TREE_OPERAND (t, 0));
591 dump_child ("body", TREE_OPERAND (t, 1));
595 dump_child ("body", TREE_OPERAND (t, 0));
599 dump_child ("cond", TREE_OPERAND (t, 0));
603 dump_child ("expr", TREE_OPERAND (t, 0));
607 dump_child ("decl", TREE_OPERAND (t, 0));
608 dump_child ("init", TREE_OPERAND (t, 1));
609 dump_child ("clnp", TREE_OPERAND (t, 2));
610 /* There really are two possible places the initializer can be.
611 After RTL expansion, the second operand is moved to the
612 position of the fourth operand, and the second operand
614 dump_child ("init", TREE_OPERAND (t, 3));
617 case CASE_LABEL_EXPR:
618 dump_child ("name", CASE_LABEL (t));
620 dump_child ("low ", CASE_LOW (t));
622 dump_child ("high", CASE_HIGH (t));
627 dump_child ("name", TREE_OPERAND (t,0));
630 dump_child ("labl", TREE_OPERAND (t, 0));
633 dump_child ("cond", TREE_OPERAND (t, 0));
634 dump_child ("body", TREE_OPERAND (t, 1));
635 if (TREE_OPERAND (t, 2))
637 dump_child ("labl", TREE_OPERAND (t,2));
641 /* There are no additional fields to print. */
646 if (dump_flag (di, TDF_ADDRESS, NULL))
647 dump_pointer (di, "addr", (void *)t);
649 /* Terminate the line. */
650 fprintf (di->stream, "\n");
653 /* Return nonzero if FLAG has been specified for the dump, and NODE
654 is not the root node of the dump. */
656 int dump_flag (dump_info_p di, int flag, tree node)
658 return (di->flags & flag) && (node != di->node);
661 /* Dump T, and all its children, on STREAM. */
664 dump_node (tree t, int flags, FILE *stream)
668 dump_queue_p next_dq;
670 /* Initialize the dump-information structure. */
679 di.nodes = splay_tree_new (splay_tree_compare_pointers, 0,
680 (splay_tree_delete_value_fn) &free);
682 /* Queue up the first node. */
683 queue (&di, t, DUMP_NONE);
685 /* Until the queue is empty, keep dumping nodes. */
687 dequeue_and_dump (&di);
690 for (dq = di.free_list; dq; dq = next_dq)
695 splay_tree_delete (di.nodes);
699 /* Table of tree dump switches. This must be consistent with the
700 TREE_DUMP_INDEX enumeration in tree.h */
701 static struct dump_file_info dump_files[TDI_end] =
703 {NULL, NULL, NULL, 0, 0, 0, 0},
704 {".tu", "translation-unit", NULL, TDF_TREE, 0, 0, 0},
705 {".class", "class-hierarchy", NULL, TDF_TREE, 0, 1, 0},
706 {".original", "tree-original", NULL, TDF_TREE, 0, 2, 0},
707 {".gimple", "tree-gimple", NULL, TDF_TREE, 0, 3, 0},
708 {".nested", "tree-nested", NULL, TDF_TREE, 0, 4, 0},
709 {".inlined", "tree-inlined", NULL, TDF_TREE, 0, 5, 0},
710 {".vcg", "tree-vcg", NULL, TDF_TREE, 0, 6, 0},
711 {NULL, "tree-all", NULL, TDF_TREE, 0, 0, 0},
712 {NULL, "rtl-all", NULL, TDF_RTL, 0, 0, 0},
713 {NULL, "ipa-all", NULL, TDF_IPA, 0, 0, 0},
715 { ".cgraph", "ipa-cgraph", NULL, TDF_IPA, 0, 0, 0},
717 { ".sibling", "rtl-sibling", NULL, TDF_RTL, 0, 1, 'i'},
718 { ".eh", "rtl-eh", NULL, TDF_RTL, 0, 2, 'h'},
719 { ".jump", "rtl-jump", NULL, TDF_RTL, 0, 3, 'j'},
720 { ".cse", "rtl-cse", NULL, TDF_RTL, 0, 4, 's'},
721 { ".gcse", "rtl-gcse", NULL, TDF_RTL, 0, 5, 'G'},
722 { ".loop", "rtl-loop", NULL, TDF_RTL, 0, 6, 'L'},
723 { ".bypass", "rtl-bypass", NULL, TDF_RTL, 0, 7, 'G'},
724 { ".cfg", "rtl-cfg", NULL, TDF_RTL, 0, 8, 'f'},
725 { ".bp", "rtl-bp", NULL, TDF_RTL, 0, 9, 'b'},
726 { ".vpt", "rtl-vpt", NULL, TDF_RTL, 0, 10, 'V'},
727 { ".ce1", "rtl-ce1", NULL, TDF_RTL, 0, 11, 'C'},
728 { ".tracer", "rtl-tracer", NULL, TDF_RTL, 0, 12, 'T'},
729 { ".loop2", "rtl-loop2", NULL, TDF_RTL, 0, 13, 'L'},
730 { ".web", "rtl-web", NULL, TDF_RTL, 0, 14, 'Z'},
731 { ".cse2", "rtl-cse2", NULL, TDF_RTL, 0, 15, 't'},
732 { ".life", "rtl-life", NULL, TDF_RTL, 0, 16, 'f'},
733 { ".combine", "rtl-combine", NULL, TDF_RTL, 0, 17, 'c'},
734 { ".ce2", "rtl-ce2", NULL, TDF_RTL, 0, 18, 'C'},
735 { ".regmove", "rtl-regmove", NULL, TDF_RTL, 0, 19, 'N'},
736 { ".sms", "rtl-sms", NULL, TDF_RTL, 0, 20, 'm'},
737 { ".sched", "rtl-sched", NULL, TDF_RTL, 0, 21, 'S'},
738 { ".lreg", "rtl-lreg", NULL, TDF_RTL, 0, 22, 'l'},
739 { ".greg", "rtl-greg", NULL, TDF_RTL, 0, 23, 'g'},
740 { ".postreload", "rtl-postreload", NULL, TDF_RTL, 0, 24, 'o'},
741 { ".gcse2", "rtl-gcse2", NULL, TDF_RTL, 0, 25, 'J'},
742 { ".flow2", "rtl-flow2", NULL, TDF_RTL, 0, 26, 'w'},
743 { ".peephole2", "rtl-peephole2", NULL, TDF_RTL, 0, 27, 'z'},
744 { ".ce3", "rtl-ce3", NULL, TDF_RTL, 0, 28, 'E'},
745 { ".rnreg", "rtl-rnreg", NULL, TDF_RTL, 0, 29, 'n'},
746 { ".bbro", "rtl-bbro", NULL, TDF_RTL, 0, 30, 'B'},
747 { ".btl", "rtl-btl", NULL, TDF_RTL, 0, 31, 'd'},
748 { ".sched2", "rtl-sched2", NULL, TDF_RTL, 0, 32, 'R'},
749 { ".stack", "rtl-stack", NULL, TDF_RTL, 0, 33, 'k'},
750 { ".vartrack", "rtl-vartrack", NULL, TDF_RTL, 0, 34, 'V'},
751 { ".mach", "rtl-mach", NULL, TDF_RTL, 0, 35, 'M'},
752 { ".dbr", "rtl-dbr", NULL, TDF_RTL, 0, 36, 'd'}
755 /* Dynamically registered tree dump files and switches. */
756 static struct dump_file_info *extra_dump_files;
757 static size_t extra_dump_files_in_use;
758 static size_t extra_dump_files_alloced;
760 /* Define a name->number mapping for a dump flag value. */
761 struct dump_option_value_info
763 const char *const name; /* the name of the value */
764 const int value; /* the value of the name */
767 /* Table of dump options. This must be consistent with the TDF_* flags
769 static const struct dump_option_value_info dump_options[] =
771 {"address", TDF_ADDRESS},
774 {"details", TDF_DETAILS},
775 {"stats", TDF_STATS},
776 {"blocks", TDF_BLOCKS},
778 {"lineno", TDF_LINENO},
780 {"stmtaddr", TDF_STMTADDR},
781 {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA
787 dump_register (const char *suffix, const char *swtch, const char *glob,
788 int flags, unsigned int num, int letter)
790 size_t this = extra_dump_files_in_use++;
792 if (this >= extra_dump_files_alloced)
794 if (extra_dump_files_alloced == 0)
795 extra_dump_files_alloced = 32;
797 extra_dump_files_alloced *= 2;
798 extra_dump_files = xrealloc (extra_dump_files,
799 sizeof (struct dump_file_info)
800 * extra_dump_files_alloced);
803 memset (&extra_dump_files[this], 0, sizeof (struct dump_file_info));
804 extra_dump_files[this].suffix = suffix;
805 extra_dump_files[this].swtch = swtch;
806 extra_dump_files[this].glob = glob;
807 extra_dump_files[this].flags = flags;
808 extra_dump_files[this].num = num;
809 extra_dump_files[this].letter = letter;
811 return this + TDI_end;
815 /* Return the dump_file_info for the given phase. */
817 struct dump_file_info *
818 get_dump_file_info (enum tree_dump_index phase)
821 return &dump_files[phase];
822 else if (phase - TDI_end >= extra_dump_files_in_use)
825 return extra_dump_files + (phase - TDI_end);
829 /* Return the name of the dump file for the given phase.
830 If the dump is not enabled, returns NULL. */
833 get_dump_file_name (enum tree_dump_index phase)
836 struct dump_file_info *dfi;
838 if (phase == TDI_none)
841 dfi = get_dump_file_info (phase);
849 const char *template;
850 if (dfi->flags & TDF_TREE)
852 else if (dfi->flags & TDF_IPA)
857 if (snprintf (dump_id, sizeof (dump_id), template, dfi->num) < 0)
861 return concat (dump_base_name, dump_id, dfi->suffix, NULL);
864 /* Begin a tree dump for PHASE. Stores any user supplied flag in
865 *FLAG_PTR and returns a stream to write to. If the dump is not
866 enabled, returns NULL.
867 Multiple calls will reopen and append to the dump file. */
870 dump_begin (enum tree_dump_index phase, int *flag_ptr)
873 struct dump_file_info *dfi;
876 if (phase == TDI_none || !dump_enabled_p (phase))
879 name = get_dump_file_name (phase);
880 dfi = get_dump_file_info (phase);
881 stream = fopen (name, dfi->state < 0 ? "w" : "a");
883 error ("could not open dump file %qs: %s", name, strerror (errno));
889 *flag_ptr = dfi->flags;
894 /* Returns nonzero if tree dump PHASE is enabled. If PHASE is
895 TDI_tree_all, return nonzero if any dump is enabled. */
898 dump_enabled_p (enum tree_dump_index phase)
900 if (phase == TDI_tree_all)
903 for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
904 if (dump_files[i].state)
906 for (i = 0; i < extra_dump_files_in_use; i++)
907 if (extra_dump_files[i].state)
913 struct dump_file_info *dfi = get_dump_file_info (phase);
918 /* Returns nonzero if tree dump PHASE has been initialized. */
921 dump_initialized_p (enum tree_dump_index phase)
923 struct dump_file_info *dfi = get_dump_file_info (phase);
924 return dfi->state > 0;
927 /* Returns the switch name of PHASE. */
930 dump_flag_name (enum tree_dump_index phase)
932 struct dump_file_info *dfi = get_dump_file_info (phase);
936 /* Finish a tree dump for PHASE. STREAM is the stream created by
940 dump_end (enum tree_dump_index phase ATTRIBUTE_UNUSED, FILE *stream)
945 /* Enable all tree dumps. Return number of enabled tree dumps. */
948 dump_enable_all (int flags, int letter)
953 for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
954 if ((dump_files[i].flags & flags)
955 && (letter == 0 || letter == dump_files[i].letter))
957 dump_files[i].state = -1;
958 dump_files[i].flags = flags;
962 for (i = 0; i < extra_dump_files_in_use; i++)
963 if ((extra_dump_files[i].flags & flags)
964 && (letter == 0 || letter == extra_dump_files[i].letter))
966 extra_dump_files[i].state = -1;
967 extra_dump_files[i].flags = flags;
974 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
975 relevant details in the dump_files array. */
978 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
980 const char *option_value;
984 if (doglob && !dfi->glob)
987 option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch);
996 const struct dump_option_value_info *option_ptr;
1002 end_ptr = strchr (ptr, '-');
1004 end_ptr = ptr + strlen (ptr);
1005 length = end_ptr - ptr;
1007 for (option_ptr = dump_options; option_ptr->name; option_ptr++)
1008 if (strlen (option_ptr->name) == length
1009 && !memcmp (option_ptr->name, ptr, length))
1011 flags |= option_ptr->value;
1014 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1015 length, ptr, dfi->swtch);
1021 dfi->flags |= flags;
1023 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1025 if (dfi->suffix == NULL)
1026 dump_enable_all (dfi->flags, 0);
1032 dump_switch_p (const char *arg)
1037 for (i = TDI_none + 1; i != TDI_end; i++)
1038 any |= dump_switch_p_1 (arg, &dump_files[i], false);
1040 /* Don't glob if we got a hit already */
1042 for (i = TDI_none + 1; i != TDI_end; i++)
1043 any |= dump_switch_p_1 (arg, &dump_files[i], true);
1045 for (i = 0; i < extra_dump_files_in_use; i++)
1046 any |= dump_switch_p_1 (arg, &extra_dump_files[i], false);
1049 for (i = 0; i < extra_dump_files_in_use; i++)
1050 any |= dump_switch_p_1 (arg, &extra_dump_files[i], true);
1056 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1059 dump_function (enum tree_dump_index phase, tree fn)
1064 stream = dump_begin (phase, &flags);
1067 dump_function_to_file (fn, stream, flags);
1068 dump_end (phase, stream);
1073 enable_rtl_dump_file (int letter)
1078 return dump_enable_all (TDF_RTL, letter) > 0;