1 /* Tree-dumping functionality for intermediate representation.
2 Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010 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-core.h"
30 #include "tree-dump.h"
31 #include "tree-pass.h"
32 #include "langhooks.h"
33 #include "tree-iterator.h"
35 /* If non-NULL, return one past-the-end of the matching SUBPART of
37 #define skip_leading_substring(whole, part) \
38 (strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part))
40 static unsigned int queue (dump_info_p
, const_tree
, int);
41 static void dump_index (dump_info_p
, unsigned int);
42 static void dequeue_and_dump (dump_info_p
);
43 static void dump_new_line (dump_info_p
);
44 static void dump_maybe_newline (dump_info_p
);
46 /* Add T to the end of the queue of nodes to dump. Returns the index
50 queue (dump_info_p di
, const_tree t
, int flags
)
56 /* Assign the next available index to T. */
59 /* Obtain a new queue node. */
63 di
->free_list
= dq
->next
;
66 dq
= XNEW (struct dump_queue
);
68 /* Create a new entry in the splay-tree. */
69 dni
= XNEW (struct dump_node_info
);
71 dni
->binfo_p
= ((flags
& DUMP_BINFO
) != 0);
72 dq
->node
= splay_tree_insert (di
->nodes
, (splay_tree_key
) t
,
73 (splay_tree_value
) dni
);
75 /* Add it to the end of the queue. */
80 di
->queue_end
->next
= dq
;
83 /* Return the index. */
88 dump_index (dump_info_p di
, unsigned int index
)
90 fprintf (di
->stream
, "@%-6u ", index
);
94 /* If T has not already been output, queue it for subsequent output.
95 FIELD is a string to print before printing the index. Then, the
96 index of T is printed. */
99 queue_and_dump_index (dump_info_p di
, const char *field
, const_tree t
, int flags
)
104 /* If there's no node, just return. This makes for fewer checks in
109 /* See if we've already queued or dumped this node. */
110 n
= splay_tree_lookup (di
->nodes
, (splay_tree_key
) t
);
112 index
= ((dump_node_info_p
) n
->value
)->index
;
114 /* If we haven't, add it to the queue. */
115 index
= queue (di
, t
, flags
);
117 /* Print the index of the node. */
118 dump_maybe_newline (di
);
119 fprintf (di
->stream
, "%-4s: ", field
);
121 dump_index (di
, index
);
124 /* Dump the type of T. */
127 queue_and_dump_type (dump_info_p di
, const_tree t
)
129 queue_and_dump_index (di
, "type", TREE_TYPE (t
), DUMP_NONE
);
132 /* Dump column control */
133 #define SOL_COLUMN 25 /* Start of line column. */
134 #define EOL_COLUMN 55 /* End of line column. */
135 #define COLUMN_ALIGNMENT 15 /* Alignment. */
137 /* Insert a new line in the dump output, and indent to an appropriate
138 place to start printing more fields. */
141 dump_new_line (dump_info_p di
)
143 fprintf (di
->stream
, "\n%*s", SOL_COLUMN
, "");
144 di
->column
= SOL_COLUMN
;
147 /* If necessary, insert a new line. */
150 dump_maybe_newline (dump_info_p di
)
154 /* See if we need a new line. */
155 if (di
->column
> EOL_COLUMN
)
157 /* See if we need any padding. */
158 else if ((extra
= (di
->column
- SOL_COLUMN
) % COLUMN_ALIGNMENT
) != 0)
160 fprintf (di
->stream
, "%*s", COLUMN_ALIGNMENT
- extra
, "");
161 di
->column
+= COLUMN_ALIGNMENT
- extra
;
165 /* Dump pointer PTR using FIELD to identify it. */
168 dump_pointer (dump_info_p di
, const char *field
, void *ptr
)
170 dump_maybe_newline (di
);
171 fprintf (di
->stream
, "%-4s: %-8lx ", field
, (unsigned long) ptr
);
175 /* Dump integer I using FIELD to identify it. */
178 dump_int (dump_info_p di
, const char *field
, int i
)
180 dump_maybe_newline (di
);
181 fprintf (di
->stream
, "%-4s: %-7d ", field
, i
);
185 /* Dump the floating point value R, using FIELD to identify it. */
188 dump_real (dump_info_p di
, const char *field
, const REAL_VALUE_TYPE
*r
)
191 real_to_decimal (buf
, r
, sizeof (buf
), 0, true);
192 dump_maybe_newline (di
);
193 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
194 di
->column
+= strlen (buf
) + 7;
197 /* Dump the fixed-point value F, using FIELD to identify it. */
200 dump_fixed (dump_info_p di
, const char *field
, const FIXED_VALUE_TYPE
*f
)
203 fixed_to_decimal (buf
, f
, sizeof (buf
));
204 dump_maybe_newline (di
);
205 fprintf (di
->stream
, "%-4s: %s ", field
, buf
);
206 di
->column
+= strlen (buf
) + 7;
210 /* Dump the string S. */
213 dump_string (dump_info_p di
, const char *string
)
215 dump_maybe_newline (di
);
216 fprintf (di
->stream
, "%-13s ", string
);
217 if (strlen (string
) > 13)
218 di
->column
+= strlen (string
) + 1;
223 /* Dump the string field S. */
226 dump_string_field (dump_info_p di
, const char *field
, const char *string
)
228 dump_maybe_newline (di
);
229 fprintf (di
->stream
, "%-4s: %-7s ", field
, string
);
230 if (strlen (string
) > 7)
231 di
->column
+= 6 + strlen (string
) + 1;
236 /* Dump the next node in the queue. */
239 dequeue_and_dump (dump_info_p di
)
243 dump_node_info_p dni
;
247 enum tree_code_class code_class
;
248 const char* code_name
;
250 /* Get the next node from the queue. */
254 dni
= (dump_node_info_p
) stn
->value
;
257 /* Remove the node from the queue, and put it on the free list. */
258 di
->queue
= dq
->next
;
261 dq
->next
= di
->free_list
;
264 /* Print the node index. */
265 dump_index (di
, index
);
266 /* And the type of node this is. */
270 code_name
= tree_code_name
[(int) TREE_CODE (t
)];
271 fprintf (di
->stream
, "%-16s ", code_name
);
274 /* Figure out what kind of node this is. */
275 code
= TREE_CODE (t
);
276 code_class
= TREE_CODE_CLASS (code
);
278 /* Although BINFOs are TREE_VECs, we dump them specially so as to be
284 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (t
);
286 dump_child ("type", BINFO_TYPE (t
));
288 if (BINFO_VIRTUAL_P (t
))
289 dump_string_field (di
, "spec", "virt");
291 dump_int (di
, "bases", BINFO_N_BASE_BINFOS (t
));
292 for (ix
= 0; BINFO_BASE_ITERATE (t
, ix
, base
); ix
++)
294 tree access
= (accesses
? VEC_index (tree
, accesses
, ix
)
295 : access_public_node
);
296 const char *string
= NULL
;
298 if (access
== access_public_node
)
300 else if (access
== access_protected_node
)
302 else if (access
== access_private_node
)
307 dump_string_field (di
, "accs", string
);
308 queue_and_dump_index (di
, "binf", base
, DUMP_BINFO
);
314 /* We can knock off a bunch of expression nodes in exactly the same
316 if (IS_EXPR_CODE_CLASS (code_class
))
318 /* If we're dumping children, dump them now. */
319 queue_and_dump_type (di
, t
);
324 dump_child ("op 0", TREE_OPERAND (t
, 0));
329 dump_child ("op 0", TREE_OPERAND (t
, 0));
330 dump_child ("op 1", TREE_OPERAND (t
, 1));
337 /* These nodes are handled explicitly below. */
346 expanded_location xloc
;
347 /* All declarations have names. */
349 dump_child ("name", DECL_NAME (t
));
350 if (DECL_ASSEMBLER_NAME_SET_P (t
)
351 && DECL_ASSEMBLER_NAME (t
) != DECL_NAME (t
))
352 dump_child ("mngl", DECL_ASSEMBLER_NAME (t
));
353 if (DECL_ABSTRACT_ORIGIN (t
))
354 dump_child ("orig", DECL_ABSTRACT_ORIGIN (t
));
356 queue_and_dump_type (di
, t
);
357 dump_child ("scpe", DECL_CONTEXT (t
));
358 /* And a source position. */
359 xloc
= expand_location (DECL_SOURCE_LOCATION (t
));
362 const char *filename
= strrchr (xloc
.file
, '/');
364 filename
= xloc
.file
;
366 /* Skip the slash. */
369 dump_maybe_newline (di
);
370 fprintf (di
->stream
, "srcp: %s:%-6d ", filename
,
372 di
->column
+= 6 + strlen (filename
) + 8;
374 /* And any declaration can be compiler-generated. */
375 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_COMMON
)
376 && DECL_ARTIFICIAL (t
))
377 dump_string_field (di
, "note", "artificial");
378 if (DECL_CHAIN (t
) && !dump_flag (di
, TDF_SLIM
, NULL
))
379 dump_child ("chain", DECL_CHAIN (t
));
381 else if (code_class
== tcc_type
)
383 /* All types have qualifiers. */
384 int quals
= lang_hooks
.tree_dump
.type_quals (t
);
386 if (quals
!= TYPE_UNQUALIFIED
)
388 fprintf (di
->stream
, "qual: %c%c%c ",
389 (quals
& TYPE_QUAL_CONST
) ? 'c' : ' ',
390 (quals
& TYPE_QUAL_VOLATILE
) ? 'v' : ' ',
391 (quals
& TYPE_QUAL_RESTRICT
) ? 'r' : ' ');
395 /* All types have associated declarations. */
396 dump_child ("name", TYPE_NAME (t
));
398 /* All types have a main variant. */
399 if (TYPE_MAIN_VARIANT (t
) != t
)
400 dump_child ("unql", TYPE_MAIN_VARIANT (t
));
403 dump_child ("size", TYPE_SIZE (t
));
405 /* All types have alignments. */
406 dump_int (di
, "algn", TYPE_ALIGN (t
));
408 else if (code_class
== tcc_constant
)
409 /* All constants can have types. */
410 queue_and_dump_type (di
, t
);
412 /* Give the language-specific code a chance to print something. If
413 it's completely taken care of things, don't bother printing
414 anything more ourselves. */
415 if (lang_hooks
.tree_dump
.dump_tree (di
, t
))
418 /* Now handle the various kinds of nodes. */
423 case IDENTIFIER_NODE
:
424 dump_string_field (di
, "strg", IDENTIFIER_POINTER (t
));
425 dump_int (di
, "lngt", IDENTIFIER_LENGTH (t
));
429 dump_child ("purp", TREE_PURPOSE (t
));
430 dump_child ("valu", TREE_VALUE (t
));
431 dump_child ("chan", TREE_CHAIN (t
));
436 tree_stmt_iterator it
;
437 for (i
= 0, it
= tsi_start (t
); !tsi_end_p (it
); tsi_next (&it
), i
++)
440 sprintf (buffer
, "%u", i
);
441 dump_child (buffer
, tsi_stmt (it
));
447 dump_int (di
, "lngt", TREE_VEC_LENGTH (t
));
448 for (i
= 0; i
< TREE_VEC_LENGTH (t
); ++i
)
451 sprintf (buffer
, "%u", i
);
452 dump_child (buffer
, TREE_VEC_ELT (t
, i
));
458 dump_int (di
, "prec", TYPE_PRECISION (t
));
459 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
460 dump_child ("min", TYPE_MIN_VALUE (t
));
461 dump_child ("max", TYPE_MAX_VALUE (t
));
463 if (code
== ENUMERAL_TYPE
)
464 dump_child ("csts", TYPE_VALUES (t
));
468 dump_int (di
, "prec", TYPE_PRECISION (t
));
471 case FIXED_POINT_TYPE
:
472 dump_int (di
, "prec", TYPE_PRECISION (t
));
473 dump_string_field (di
, "sign", TYPE_UNSIGNED (t
) ? "unsigned": "signed");
474 dump_string_field (di
, "saturating",
475 TYPE_SATURATING (t
) ? "saturating": "non-saturating");
479 dump_child ("ptd", TREE_TYPE (t
));
483 dump_child ("refd", TREE_TYPE (t
));
487 dump_child ("clas", TYPE_METHOD_BASETYPE (t
));
491 dump_child ("retn", TREE_TYPE (t
));
492 dump_child ("prms", TYPE_ARG_TYPES (t
));
496 dump_child ("elts", TREE_TYPE (t
));
497 dump_child ("domn", TYPE_DOMAIN (t
));
502 if (TREE_CODE (t
) == RECORD_TYPE
)
503 dump_string_field (di
, "tag", "struct");
505 dump_string_field (di
, "tag", "union");
507 dump_child ("flds", TYPE_FIELDS (t
));
508 dump_child ("fncs", TYPE_METHODS (t
));
509 queue_and_dump_index (di
, "binf", TYPE_BINFO (t
),
514 dump_child ("cnst", DECL_INITIAL (t
));
517 case DEBUG_EXPR_DECL
:
518 dump_int (di
, "-uid", DEBUG_TEMP_UID (t
));
525 if (TREE_CODE (t
) == PARM_DECL
)
526 dump_child ("argt", DECL_ARG_TYPE (t
));
528 dump_child ("init", DECL_INITIAL (t
));
529 dump_child ("size", DECL_SIZE (t
));
530 dump_int (di
, "algn", DECL_ALIGN (t
));
532 if (TREE_CODE (t
) == FIELD_DECL
)
534 if (DECL_FIELD_OFFSET (t
))
535 dump_child ("bpos", bit_position (t
));
537 else if (TREE_CODE (t
) == VAR_DECL
538 || TREE_CODE (t
) == PARM_DECL
)
540 dump_int (di
, "used", TREE_USED (t
));
541 if (DECL_REGISTER (t
))
542 dump_string_field (di
, "spec", "register");
547 dump_child ("args", DECL_ARGUMENTS (t
));
548 if (DECL_EXTERNAL (t
))
549 dump_string_field (di
, "body", "undefined");
551 dump_string_field (di
, "link", "extern");
553 dump_string_field (di
, "link", "static");
554 if (DECL_SAVED_TREE (t
) && !dump_flag (di
, TDF_SLIM
, t
))
555 dump_child ("body", DECL_SAVED_TREE (t
));
559 if (TREE_INT_CST_HIGH (t
))
560 dump_int (di
, "high", TREE_INT_CST_HIGH (t
));
561 dump_int (di
, "low", TREE_INT_CST_LOW (t
));
565 fprintf (di
->stream
, "strg: %-7s ", TREE_STRING_POINTER (t
));
566 dump_int (di
, "lngt", TREE_STRING_LENGTH (t
));
570 dump_real (di
, "valu", TREE_REAL_CST_PTR (t
));
574 dump_fixed (di
, "valu", TREE_FIXED_CST_PTR (t
));
580 case CLEANUP_POINT_EXPR
:
584 /* These nodes are unary, but do not have code class `1'. */
585 dump_child ("op 0", TREE_OPERAND (t
, 0));
588 case TRUTH_ANDIF_EXPR
:
589 case TRUTH_ORIF_EXPR
:
593 case PREDECREMENT_EXPR
:
594 case PREINCREMENT_EXPR
:
595 case POSTDECREMENT_EXPR
:
596 case POSTINCREMENT_EXPR
:
597 /* These nodes are binary, but do not have code class `2'. */
598 dump_child ("op 0", TREE_OPERAND (t
, 0));
599 dump_child ("op 1", TREE_OPERAND (t
, 1));
603 dump_child ("op 0", TREE_OPERAND (t
, 0));
604 dump_child ("op 1", TREE_OPERAND (t
, 1));
605 dump_child ("op 2", TREE_OPERAND (t
, 2));
609 case ARRAY_RANGE_REF
:
610 dump_child ("op 0", TREE_OPERAND (t
, 0));
611 dump_child ("op 1", TREE_OPERAND (t
, 1));
612 dump_child ("op 2", TREE_OPERAND (t
, 2));
613 dump_child ("op 3", TREE_OPERAND (t
, 3));
617 dump_child ("op 0", TREE_OPERAND (t
, 0));
618 dump_child ("op 1", TREE_OPERAND (t
, 1));
619 dump_child ("op 2", TREE_OPERAND (t
, 2));
622 case TRY_FINALLY_EXPR
:
623 dump_child ("op 0", TREE_OPERAND (t
, 0));
624 dump_child ("op 1", TREE_OPERAND (t
, 1));
631 call_expr_arg_iterator iter
;
632 dump_child ("fn", CALL_EXPR_FN (t
));
633 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
636 sprintf (buffer
, "%u", i
);
637 dump_child (buffer
, arg
);
645 unsigned HOST_WIDE_INT cnt
;
647 dump_int (di
, "lngt", VEC_length (constructor_elt
,
648 CONSTRUCTOR_ELTS (t
)));
649 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t
), cnt
, index
, value
)
651 dump_child ("idx", index
);
652 dump_child ("val", value
);
658 dump_child ("vars", TREE_OPERAND (t
, 0));
659 dump_child ("body", TREE_OPERAND (t
, 1));
663 dump_child ("body", TREE_OPERAND (t
, 0));
667 dump_child ("cond", TREE_OPERAND (t
, 0));
671 dump_child ("expr", TREE_OPERAND (t
, 0));
675 dump_child ("decl", TREE_OPERAND (t
, 0));
676 dump_child ("init", TREE_OPERAND (t
, 1));
677 dump_child ("clnp", TREE_OPERAND (t
, 2));
678 /* There really are two possible places the initializer can be.
679 After RTL expansion, the second operand is moved to the
680 position of the fourth operand, and the second operand
682 dump_child ("init", TREE_OPERAND (t
, 3));
685 case CASE_LABEL_EXPR
:
686 dump_child ("name", CASE_LABEL (t
));
689 dump_child ("low ", CASE_LOW (t
));
691 dump_child ("high", CASE_HIGH (t
));
695 dump_child ("name", TREE_OPERAND (t
,0));
698 dump_child ("labl", TREE_OPERAND (t
, 0));
701 dump_child ("cond", TREE_OPERAND (t
, 0));
702 dump_child ("body", TREE_OPERAND (t
, 1));
703 if (TREE_OPERAND (t
, 2))
705 dump_child ("labl", TREE_OPERAND (t
,2));
711 fprintf (di
->stream
, "%s\n", omp_clause_code_name
[OMP_CLAUSE_CODE (t
)]);
712 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)]; i
++)
713 dump_child ("op: ", OMP_CLAUSE_OPERAND (t
, i
));
717 /* There are no additional fields to print. */
722 if (dump_flag (di
, TDF_ADDRESS
, NULL
))
723 dump_pointer (di
, "addr", (void *)t
);
725 /* Terminate the line. */
726 fprintf (di
->stream
, "\n");
729 /* Return nonzero if FLAG has been specified for the dump, and NODE
730 is not the root node of the dump. */
732 int dump_flag (dump_info_p di
, int flag
, const_tree node
)
734 return (di
->flags
& flag
) && (node
!= di
->node
);
737 /* Dump T, and all its children, on STREAM. */
740 dump_node (const_tree t
, int flags
, FILE *stream
)
744 dump_queue_p next_dq
;
746 /* Initialize the dump-information structure. */
755 di
.nodes
= splay_tree_new (splay_tree_compare_pointers
, 0,
756 (splay_tree_delete_value_fn
) &free
);
758 /* Queue up the first node. */
759 queue (&di
, t
, DUMP_NONE
);
761 /* Until the queue is empty, keep dumping nodes. */
763 dequeue_and_dump (&di
);
766 for (dq
= di
.free_list
; dq
; dq
= next_dq
)
771 splay_tree_delete (di
.nodes
);
775 /* Table of tree dump switches. This must be consistent with the
776 tree_dump_index enumeration in tree-pass.h. */
777 static struct dump_file_info dump_files
[TDI_end
] =
779 {NULL
, NULL
, NULL
, 0, 0, 0},
780 {".cgraph", "ipa-cgraph", NULL
, TDF_IPA
, 0, 0},
781 {".tu", "translation-unit", NULL
, TDF_TREE
, 0, 1},
782 {".class", "class-hierarchy", NULL
, TDF_TREE
, 0, 2},
783 {".original", "tree-original", NULL
, TDF_TREE
, 0, 3},
784 {".gimple", "tree-gimple", NULL
, TDF_TREE
, 0, 4},
785 {".nested", "tree-nested", NULL
, TDF_TREE
, 0, 5},
786 {".vcg", "tree-vcg", NULL
, TDF_TREE
, 0, 6},
787 {".ads", "ada-spec", NULL
, 0, 0, 7},
788 #define FIRST_AUTO_NUMBERED_DUMP 8
790 {NULL
, "tree-all", NULL
, TDF_TREE
, 0, 0},
791 {NULL
, "rtl-all", NULL
, TDF_RTL
, 0, 0},
792 {NULL
, "ipa-all", NULL
, TDF_IPA
, 0, 0},
795 /* Dynamically registered tree dump files and switches. */
796 static struct dump_file_info
*extra_dump_files
;
797 static size_t extra_dump_files_in_use
;
798 static size_t extra_dump_files_alloced
;
800 /* Define a name->number mapping for a dump flag value. */
801 struct dump_option_value_info
803 const char *const name
; /* the name of the value */
804 const int value
; /* the value of the name */
807 /* Table of dump options. This must be consistent with the TDF_* flags
809 static const struct dump_option_value_info dump_options
[] =
811 {"address", TDF_ADDRESS
},
812 {"asmname", TDF_ASMNAME
},
815 {"graph", TDF_GRAPH
},
816 {"details", TDF_DETAILS
},
817 {"stats", TDF_STATS
},
818 {"blocks", TDF_BLOCKS
},
820 {"lineno", TDF_LINENO
},
822 {"stmtaddr", TDF_STMTADDR
},
823 {"memsyms", TDF_MEMSYMS
},
824 {"verbose", TDF_VERBOSE
},
826 {"alias", TDF_ALIAS
},
827 {"nouid", TDF_NOUID
},
828 {"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
)},
836 dump_register (const char *suffix
, const char *swtch
, const char *glob
,
839 static int next_dump
= FIRST_AUTO_NUMBERED_DUMP
;
840 int num
= next_dump
++;
842 size_t count
= extra_dump_files_in_use
++;
844 if (count
>= extra_dump_files_alloced
)
846 if (extra_dump_files_alloced
== 0)
847 extra_dump_files_alloced
= 32;
849 extra_dump_files_alloced
*= 2;
850 extra_dump_files
= XRESIZEVEC (struct dump_file_info
,
852 extra_dump_files_alloced
);
855 memset (&extra_dump_files
[count
], 0, sizeof (struct dump_file_info
));
856 extra_dump_files
[count
].suffix
= suffix
;
857 extra_dump_files
[count
].swtch
= swtch
;
858 extra_dump_files
[count
].glob
= glob
;
859 extra_dump_files
[count
].flags
= flags
;
860 extra_dump_files
[count
].num
= num
;
862 return count
+ TDI_end
;
866 /* Return the dump_file_info for the given phase. */
868 struct dump_file_info
*
869 get_dump_file_info (int phase
)
872 return &dump_files
[phase
];
873 else if ((size_t) (phase
- TDI_end
) >= extra_dump_files_in_use
)
876 return extra_dump_files
+ (phase
- TDI_end
);
880 /* Return the name of the dump file for the given phase.
881 If the dump is not enabled, returns NULL. */
884 get_dump_file_name (int phase
)
887 struct dump_file_info
*dfi
;
889 if (phase
== TDI_none
)
892 dfi
= get_dump_file_info (phase
);
901 if (dfi
->flags
& TDF_TREE
)
903 else if (dfi
->flags
& TDF_IPA
)
908 if (snprintf (dump_id
, sizeof (dump_id
), ".%03d%c", dfi
->num
, suffix
) < 0)
912 return concat (dump_base_name
, dump_id
, dfi
->suffix
, NULL
);
915 /* Begin a tree dump for PHASE. Stores any user supplied flag in
916 *FLAG_PTR and returns a stream to write to. If the dump is not
917 enabled, returns NULL.
918 Multiple calls will reopen and append to the dump file. */
921 dump_begin (int phase
, int *flag_ptr
)
924 struct dump_file_info
*dfi
;
927 if (phase
== TDI_none
|| !dump_enabled_p (phase
))
930 name
= get_dump_file_name (phase
);
931 dfi
= get_dump_file_info (phase
);
932 stream
= fopen (name
, dfi
->state
< 0 ? "w" : "a");
934 error ("could not open dump file %qs: %m", name
);
940 *flag_ptr
= dfi
->flags
;
945 /* Returns nonzero if tree dump PHASE is enabled. If PHASE is
946 TDI_tree_all, return nonzero if any dump is enabled. */
949 dump_enabled_p (int phase
)
951 if (phase
== TDI_tree_all
)
954 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
955 if (dump_files
[i
].state
)
957 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
958 if (extra_dump_files
[i
].state
)
964 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
969 /* Returns nonzero if tree dump PHASE has been initialized. */
972 dump_initialized_p (int phase
)
974 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
975 return dfi
->state
> 0;
978 /* Returns the switch name of PHASE. */
981 dump_flag_name (int phase
)
983 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
987 /* Finish a tree dump for PHASE. STREAM is the stream created by
991 dump_end (int phase ATTRIBUTE_UNUSED
, FILE *stream
)
996 /* Enable all tree dumps. Return number of enabled tree dumps. */
999 dump_enable_all (int flags
)
1001 int ir_dump_type
= (flags
& (TDF_TREE
| TDF_RTL
| TDF_IPA
));
1005 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1006 if ((dump_files
[i
].flags
& ir_dump_type
))
1008 dump_files
[i
].state
= -1;
1009 dump_files
[i
].flags
|= flags
;
1013 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1014 if ((extra_dump_files
[i
].flags
& ir_dump_type
))
1016 extra_dump_files
[i
].state
= -1;
1017 extra_dump_files
[i
].flags
|= flags
;
1024 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1025 relevant details in the dump_files array. */
1028 dump_switch_p_1 (const char *arg
, struct dump_file_info
*dfi
, bool doglob
)
1030 const char *option_value
;
1034 if (doglob
&& !dfi
->glob
)
1037 option_value
= skip_leading_substring (arg
, doglob
? dfi
->glob
: dfi
->swtch
);
1041 if (*option_value
&& *option_value
!= '-')
1049 const struct dump_option_value_info
*option_ptr
;
1050 const char *end_ptr
;
1055 end_ptr
= strchr (ptr
, '-');
1057 end_ptr
= ptr
+ strlen (ptr
);
1058 length
= end_ptr
- ptr
;
1060 for (option_ptr
= dump_options
; option_ptr
->name
; option_ptr
++)
1061 if (strlen (option_ptr
->name
) == length
1062 && !memcmp (option_ptr
->name
, ptr
, length
))
1064 flags
|= option_ptr
->value
;
1067 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1068 length
, ptr
, dfi
->swtch
);
1074 dfi
->flags
|= flags
;
1076 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1078 if (dfi
->suffix
== NULL
)
1079 dump_enable_all (dfi
->flags
);
1085 dump_switch_p (const char *arg
)
1090 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1091 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], false);
1093 /* Don't glob if we got a hit already */
1095 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1096 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], true);
1098 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1099 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], false);
1102 for (i
= 0; i
< extra_dump_files_in_use
; i
++)
1103 any
|= dump_switch_p_1 (arg
, &extra_dump_files
[i
], true);
1109 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1112 dump_function (int phase
, tree fn
)
1117 stream
= dump_begin (phase
, &flags
);
1120 dump_function_to_file (fn
, stream
, flags
);
1121 dump_end (phase
, stream
);
1126 enable_rtl_dump_file (void)
1128 return dump_enable_all (TDF_RTL
| TDF_DETAILS
| TDF_BLOCKS
) > 0;