1 /* Dump infrastructure for optimizations and intermediate representation.
2 Copyright (C) 2012-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
25 #include "gimple-pretty-print.h"
26 #include "diagnostic-core.h"
29 #include "profile-count.h"
31 #include "langhooks.h"
32 #include "backend.h" /* for gimple.h. */
33 #include "gimple.h" /* for dump_user_location_t ctor. */
34 #include "rtl.h" /* for dump_user_location_t ctor. */
37 #include "dump-context.h"
39 #include "tree-pass.h" /* for "current_pass". */
40 #include "optinfo-emit-json.h"
41 #include "stringpool.h" /* for get_identifier. */
43 /* If non-NULL, return one past-the-end of the matching SUBPART of
45 #define skip_leading_substring(whole, part) \
46 (strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part))
48 static dump_flags_t pflags
; /* current dump_flags */
50 static void dump_loc (dump_flags_t
, FILE *, location_t
);
52 /* Current -fopt-info output stream, if any, and flags. */
53 static FILE *alt_dump_file
= NULL
;
54 static dump_flags_t alt_flags
;
56 static FILE *dump_open_alternate_stream (struct dump_file_info
*);
58 /* These are currently used for communicating between passes.
59 However, instead of accessing them directly, the passes can use
60 dump_printf () for dumps. */
61 FILE *dump_file
= NULL
;
62 const char *dump_file_name
;
63 dump_flags_t dump_flags
;
64 bool dumps_are_enabled
= false;
67 /* Set global "dump_file" to NEW_DUMP_FILE, refreshing the "dumps_are_enabled"
71 set_dump_file (FILE *new_dump_file
)
73 dumpfile_ensure_any_optinfo_are_flushed ();
74 dump_file
= new_dump_file
;
75 dump_context::get ().refresh_dumps_are_enabled ();
78 /* Set "alt_dump_file" to NEW_ALT_DUMP_FILE, refreshing the "dumps_are_enabled"
82 set_alt_dump_file (FILE *new_alt_dump_file
)
84 dumpfile_ensure_any_optinfo_are_flushed ();
85 alt_dump_file
= new_alt_dump_file
;
86 dump_context::get ().refresh_dumps_are_enabled ();
89 #define DUMP_FILE_INFO(suffix, swtch, dkind, num) \
90 {suffix, swtch, NULL, NULL, NULL, NULL, NULL, dkind, TDF_NONE, TDF_NONE, \
91 OPTGROUP_NONE, 0, 0, num, false, false}
93 /* Table of tree dump switches. This must be consistent with the
94 TREE_DUMP_INDEX enumeration in dumpfile.h. */
95 static struct dump_file_info dump_files
[TDI_end
] =
97 DUMP_FILE_INFO (NULL
, NULL
, DK_none
, 0),
98 DUMP_FILE_INFO (".cgraph", "ipa-cgraph", DK_ipa
, 0),
99 DUMP_FILE_INFO (".type-inheritance", "ipa-type-inheritance", DK_ipa
, 0),
100 DUMP_FILE_INFO (".ipa-clones", "ipa-clones", DK_ipa
, 0),
101 DUMP_FILE_INFO (".original", "tree-original", DK_tree
, 0),
102 DUMP_FILE_INFO (".gimple", "tree-gimple", DK_tree
, 0),
103 DUMP_FILE_INFO (".nested", "tree-nested", DK_tree
, 0),
104 DUMP_FILE_INFO (".lto-stream-out", "ipa-lto-stream-out", DK_ipa
, 0),
105 #define FIRST_AUTO_NUMBERED_DUMP 1
106 #define FIRST_ME_AUTO_NUMBERED_DUMP 4
108 DUMP_FILE_INFO (NULL
, "lang-all", DK_lang
, 0),
109 DUMP_FILE_INFO (NULL
, "tree-all", DK_tree
, 0),
110 DUMP_FILE_INFO (NULL
, "rtl-all", DK_rtl
, 0),
111 DUMP_FILE_INFO (NULL
, "ipa-all", DK_ipa
, 0),
114 /* Table of dump options. This must be consistent with the TDF_* flags
115 in dumpfile.h and opt_info_options below. */
116 static const kv_pair
<dump_flags_t
> dump_options
[] =
118 {"address", TDF_ADDRESS
},
119 {"asmname", TDF_ASMNAME
},
122 {"graph", TDF_GRAPH
},
123 {"details", (TDF_DETAILS
| MSG_OPTIMIZED_LOCATIONS
124 | MSG_MISSED_OPTIMIZATION
126 {"cselib", TDF_CSELIB
},
127 {"stats", TDF_STATS
},
128 {"blocks", TDF_BLOCKS
},
130 {"lineno", TDF_LINENO
},
132 {"stmtaddr", TDF_STMTADDR
},
133 {"memsyms", TDF_MEMSYMS
},
135 {"alias", TDF_ALIAS
},
136 {"nouid", TDF_NOUID
},
137 {"enumerate_locals", TDF_ENUMERATE_LOCALS
},
139 {"gimple", TDF_GIMPLE
},
140 {"folding", TDF_FOLDING
},
141 {"optimized", MSG_OPTIMIZED_LOCATIONS
},
142 {"missed", MSG_MISSED_OPTIMIZATION
},
144 {"optall", MSG_ALL_KINDS
},
145 {"all", dump_flags_t (TDF_ALL_VALUES
146 & ~(TDF_RAW
| TDF_SLIM
| TDF_LINENO
| TDF_GRAPH
147 | TDF_STMTADDR
| TDF_RHS_ONLY
| TDF_NOUID
148 | TDF_ENUMERATE_LOCALS
| TDF_SCEV
| TDF_GIMPLE
))},
152 /* A subset of the dump_options table which is used for -fopt-info
153 types. This must be consistent with the MSG_* flags in dumpfile.h.
155 static const kv_pair
<dump_flags_t
> optinfo_verbosity_options
[] =
157 {"optimized", MSG_OPTIMIZED_LOCATIONS
},
158 {"missed", MSG_MISSED_OPTIMIZATION
},
160 {"all", MSG_ALL_KINDS
},
161 {"internals", MSG_PRIORITY_INTERNALS
},
165 /* Flags used for -fopt-info groups. */
166 const kv_pair
<optgroup_flags_t
> optgroup_options
[] =
168 {"ipa", OPTGROUP_IPA
},
169 {"loop", OPTGROUP_LOOP
},
170 {"inline", OPTGROUP_INLINE
},
171 {"omp", OPTGROUP_OMP
},
172 {"vec", OPTGROUP_VEC
},
173 {"optall", OPTGROUP_ALL
},
174 {NULL
, OPTGROUP_NONE
}
177 gcc::dump_manager::dump_manager ():
178 m_next_dump (FIRST_AUTO_NUMBERED_DUMP
),
179 m_extra_dump_files (NULL
),
180 m_extra_dump_files_in_use (0),
181 m_extra_dump_files_alloced (0),
182 m_optgroup_flags (OPTGROUP_NONE
),
183 m_optinfo_flags (TDF_NONE
),
184 m_optinfo_filename (NULL
)
188 gcc::dump_manager::~dump_manager ()
190 free (m_optinfo_filename
);
191 for (size_t i
= 0; i
< m_extra_dump_files_in_use
; i
++)
193 dump_file_info
*dfi
= &m_extra_dump_files
[i
];
194 /* suffix, swtch, glob are statically allocated for the entries
195 in dump_files, and for statistics, but are dynamically allocated
196 for those for passes. */
197 if (dfi
->owns_strings
)
199 XDELETEVEC (const_cast <char *> (dfi
->suffix
));
200 XDELETEVEC (const_cast <char *> (dfi
->swtch
));
201 XDELETEVEC (const_cast <char *> (dfi
->glob
));
203 /* These, if non-NULL, are always dynamically allocated. */
204 XDELETEVEC (const_cast <char *> (dfi
->pfilename
));
205 XDELETEVEC (const_cast <char *> (dfi
->alt_filename
));
207 XDELETEVEC (m_extra_dump_files
);
212 dump_register (const char *suffix
, const char *swtch
, const char *glob
,
213 dump_kind dkind
, optgroup_flags_t optgroup_flags
,
216 int num
= m_next_dump
++;
218 size_t count
= m_extra_dump_files_in_use
++;
220 if (count
>= m_extra_dump_files_alloced
)
222 if (m_extra_dump_files_alloced
== 0)
223 m_extra_dump_files_alloced
= 512;
225 m_extra_dump_files_alloced
*= 2;
226 m_extra_dump_files
= XRESIZEVEC (struct dump_file_info
,
228 m_extra_dump_files_alloced
);
230 /* Construct a new object in the space allocated above. */
231 new (m_extra_dump_files
+ count
) dump_file_info ();
235 /* Zero out the already constructed object. */
236 m_extra_dump_files
[count
] = dump_file_info ();
239 m_extra_dump_files
[count
].suffix
= suffix
;
240 m_extra_dump_files
[count
].swtch
= swtch
;
241 m_extra_dump_files
[count
].glob
= glob
;
242 m_extra_dump_files
[count
].dkind
= dkind
;
243 m_extra_dump_files
[count
].optgroup_flags
= optgroup_flags
;
244 m_extra_dump_files
[count
].num
= num
;
245 m_extra_dump_files
[count
].owns_strings
= take_ownership
;
247 return count
+ TDI_end
;
251 /* Allow languages and middle-end to register their dumps before the
252 optimization passes. */
258 lang_hooks
.register_dumps (this);
259 /* If this assert fails, some FE registered more than
260 FIRST_ME_AUTO_NUMBERED_DUMP - FIRST_AUTO_NUMBERED_DUMP
261 dump files. Bump FIRST_ME_AUTO_NUMBERED_DUMP accordingly. */
262 gcc_assert (m_next_dump
<= FIRST_ME_AUTO_NUMBERED_DUMP
);
263 m_next_dump
= FIRST_ME_AUTO_NUMBERED_DUMP
;
264 dump_files
[TDI_original
].num
= m_next_dump
++;
265 dump_files
[TDI_gimple
].num
= m_next_dump
++;
266 dump_files
[TDI_nested
].num
= m_next_dump
++;
270 /* Return the dump_file_info for the given phase. */
272 struct dump_file_info
*
274 get_dump_file_info (int phase
) const
277 return &dump_files
[phase
];
278 else if ((size_t) (phase
- TDI_end
) >= m_extra_dump_files_in_use
)
281 return m_extra_dump_files
+ (phase
- TDI_end
);
284 /* Locate the dump_file_info with swtch equal to SWTCH,
285 or return NULL if no such dump_file_info exists. */
287 struct dump_file_info
*
289 get_dump_file_info_by_switch (const char *swtch
) const
291 for (unsigned i
= 0; i
< m_extra_dump_files_in_use
; i
++)
292 if (strcmp (m_extra_dump_files
[i
].swtch
, swtch
) == 0)
293 return &m_extra_dump_files
[i
];
300 /* Return the name of the dump file for the given phase.
301 The caller is responsible for calling free on the returned
303 If the dump is not enabled, returns NULL. */
307 get_dump_file_name (int phase
, int part
) const
309 struct dump_file_info
*dfi
;
311 if (phase
== TDI_none
)
314 dfi
= get_dump_file_info (phase
);
316 return get_dump_file_name (dfi
, part
);
319 /* Return the name of the dump file for the given dump_file_info.
320 The caller is responsible for calling free on the returned
322 If the dump is not enabled, returns NULL. */
326 get_dump_file_name (struct dump_file_info
*dfi
, int part
) const
332 if (dfi
->pstate
== 0)
335 /* If available, use the command line dump filename. */
337 return xstrdup (dfi
->pfilename
);
343 /* (null), LANG, TREE, RTL, IPA. */
344 char suffix
= " ltri"[dfi
->dkind
];
346 if (snprintf (dump_id
, sizeof (dump_id
), ".%03d%c", dfi
->num
, suffix
) < 0)
353 snprintf (part_id
, sizeof (part_id
), ".%i", part
);
354 return concat (dump_base_name
, dump_id
, part_id
, dfi
->suffix
, NULL
);
357 return concat (dump_base_name
, dump_id
, dfi
->suffix
, NULL
);
360 /* Open a dump file called FILENAME. Some filenames are special and
361 refer to the standard streams. TRUNC indicates whether this is the
362 first open (so the file should be truncated, rather than appended).
363 An error message is emitted in the event of failure. */
366 dump_open (const char *filename
, bool trunc
)
368 if (strcmp ("stderr", filename
) == 0)
371 if (strcmp ("stdout", filename
) == 0
372 || strcmp ("-", filename
) == 0)
375 FILE *stream
= fopen (filename
, trunc
? "w" : "a");
378 error ("could not open dump file %qs: %m", filename
);
382 /* For a given DFI, open an alternate dump filename (which could also
383 be a standard stream such as stdout/stderr). If the alternate dump
384 file cannot be opened, return NULL. */
387 dump_open_alternate_stream (struct dump_file_info
*dfi
)
389 if (!dfi
->alt_filename
)
393 return dfi
->alt_stream
;
395 FILE *stream
= dump_open (dfi
->alt_filename
, dfi
->alt_state
< 0);
403 /* Construct a dump_user_location_t from STMT (using its location and
406 dump_user_location_t::dump_user_location_t (const gimple
*stmt
)
407 : m_count (), m_loc (UNKNOWN_LOCATION
)
412 m_count
= stmt
->bb
->count
;
413 m_loc
= gimple_location (stmt
);
417 /* Construct a dump_user_location_t from an RTL instruction (using its
418 location and hotness). */
420 dump_user_location_t::dump_user_location_t (const rtx_insn
*insn
)
421 : m_count (), m_loc (UNKNOWN_LOCATION
)
425 basic_block bb
= BLOCK_FOR_INSN (insn
);
428 m_loc
= INSN_LOCATION (insn
);
432 /* Construct from a function declaration. This one requires spelling out
433 to avoid accidentally constructing from other kinds of tree. */
436 dump_user_location_t::from_function_decl (tree fndecl
)
440 // FIXME: profile count for function?
441 return dump_user_location_t (profile_count (),
442 DECL_SOURCE_LOCATION (fndecl
));
445 /* Extract the MSG_* component from DUMP_KIND and return a string for use
446 as a prefix to dump messages.
447 These match the strings in optinfo_verbosity_options and thus the
448 "OPTIONS" within "-fopt-info-OPTIONS". */
451 kind_as_string (dump_flags_t dump_kind
)
453 switch (dump_kind
& MSG_ALL_KINDS
)
457 case MSG_OPTIMIZED_LOCATIONS
:
459 case MSG_MISSED_OPTIMIZATION
:
466 /* Print source location on DFILE if enabled. */
469 dump_loc (dump_flags_t dump_kind
, FILE *dfile
, location_t loc
)
473 if (LOCATION_LOCUS (loc
) > BUILTINS_LOCATION
)
474 fprintf (dfile
, "%s:%d:%d: ", LOCATION_FILE (loc
),
475 LOCATION_LINE (loc
), LOCATION_COLUMN (loc
));
476 else if (current_function_decl
)
477 fprintf (dfile
, "%s:%d:%d: ",
478 DECL_SOURCE_FILE (current_function_decl
),
479 DECL_SOURCE_LINE (current_function_decl
),
480 DECL_SOURCE_COLUMN (current_function_decl
));
481 fprintf (dfile
, "%s: ", kind_as_string (dump_kind
));
482 /* Indentation based on scope depth. */
483 fprintf (dfile
, "%*s", get_dump_scope_depth (), "");
487 /* Print source location to PP if enabled. */
490 dump_loc (dump_flags_t dump_kind
, pretty_printer
*pp
, location_t loc
)
494 if (LOCATION_LOCUS (loc
) > BUILTINS_LOCATION
)
495 pp_printf (pp
, "%s:%d:%d: ", LOCATION_FILE (loc
),
496 LOCATION_LINE (loc
), LOCATION_COLUMN (loc
));
497 else if (current_function_decl
)
498 pp_printf (pp
, "%s:%d:%d: ",
499 DECL_SOURCE_FILE (current_function_decl
),
500 DECL_SOURCE_LINE (current_function_decl
),
501 DECL_SOURCE_COLUMN (current_function_decl
));
502 pp_printf (pp
, "%s: ", kind_as_string (dump_kind
));
503 /* Indentation based on scope depth. */
504 for (unsigned i
= 0; i
< get_dump_scope_depth (); i
++)
505 pp_character (pp
, ' ');
509 /* Implementation of dump_context member functions. */
511 /* dump_context's dtor. */
513 dump_context::~dump_context ()
518 /* Update the "dumps_are_enabled" global; to be called whenever dump_file
519 or alt_dump_file change, or when changing dump_context in selftests. */
522 dump_context::refresh_dumps_are_enabled ()
524 dumps_are_enabled
= (dump_file
|| alt_dump_file
|| optinfo_enabled_p ()
528 /* Determine if a message of kind DUMP_KIND and at the current scope depth
531 Only show messages that match FILTER both on their kind *and*
535 dump_context::apply_dump_filter_p (dump_flags_t dump_kind
,
536 dump_flags_t filter
) const
538 /* Few messages, if any, have an explicit MSG_PRIORITY.
539 If DUMP_KIND does, we'll use it.
540 Otherwise, generate an implicit priority value for the message based
541 on the current scope depth.
542 Messages at the top-level scope are MSG_PRIORITY_USER_FACING,
543 whereas those in nested scopes are MSG_PRIORITY_INTERNALS. */
544 if (!(dump_kind
& MSG_ALL_PRIORITIES
))
546 dump_flags_t implicit_priority
548 ? MSG_PRIORITY_INTERNALS
549 : MSG_PRIORITY_USER_FACING
);
550 dump_kind
|= implicit_priority
;
553 return (dump_kind
& (filter
& MSG_ALL_KINDS
)
554 && dump_kind
& (filter
& MSG_ALL_PRIORITIES
));
557 /* Print LOC to the appropriate dump destinations, given DUMP_KIND.
558 If optinfos are enabled, begin a new optinfo. */
561 dump_context::dump_loc (dump_flags_t dump_kind
, const dump_location_t
&loc
)
565 dump_loc_immediate (dump_kind
, loc
);
567 if (optinfo_enabled_p ())
569 optinfo
&info
= begin_next_optinfo (loc
);
570 info
.handle_dump_file_kind (dump_kind
);
574 /* As dump_loc above, but without starting a new optinfo. */
577 dump_context::dump_loc_immediate (dump_flags_t dump_kind
,
578 const dump_location_t
&loc
)
580 location_t srcloc
= loc
.get_location_t ();
582 if (dump_file
&& apply_dump_filter_p (dump_kind
, pflags
))
583 ::dump_loc (dump_kind
, dump_file
, srcloc
);
585 if (alt_dump_file
&& apply_dump_filter_p (dump_kind
, alt_flags
))
586 ::dump_loc (dump_kind
, alt_dump_file
, srcloc
);
588 /* Support for temp_dump_context in selftests. */
589 if (m_test_pp
&& apply_dump_filter_p (dump_kind
, m_test_pp_flags
))
590 ::dump_loc (dump_kind
, m_test_pp
, srcloc
);
593 /* Make an item for the given dump call, equivalent to print_gimple_stmt. */
595 static optinfo_item
*
596 make_item_for_dump_gimple_stmt (gimple
*stmt
, int spc
, dump_flags_t dump_flags
)
599 pp_needs_newline (&pp
) = true;
600 pp_gimple_stmt_1 (&pp
, stmt
, spc
, dump_flags
);
604 = new optinfo_item (OPTINFO_ITEM_KIND_GIMPLE
, gimple_location (stmt
),
605 xstrdup (pp_formatted_text (&pp
)));
609 /* Dump gimple statement GS with SPC indentation spaces and
610 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled. */
613 dump_context::dump_gimple_stmt (dump_flags_t dump_kind
,
614 dump_flags_t extra_dump_flags
,
618 = make_item_for_dump_gimple_stmt (gs
, spc
, dump_flags
| extra_dump_flags
);
619 emit_item (item
, dump_kind
);
621 if (optinfo_enabled_p ())
623 optinfo
&info
= ensure_pending_optinfo ();
624 info
.handle_dump_file_kind (dump_kind
);
625 info
.add_item (item
);
631 /* Similar to dump_gimple_stmt, except additionally print source location. */
634 dump_context::dump_gimple_stmt_loc (dump_flags_t dump_kind
,
635 const dump_location_t
&loc
,
636 dump_flags_t extra_dump_flags
,
639 dump_loc (dump_kind
, loc
);
640 dump_gimple_stmt (dump_kind
, extra_dump_flags
, gs
, spc
);
643 /* Make an item for the given dump call, equivalent to print_gimple_expr. */
645 static optinfo_item
*
646 make_item_for_dump_gimple_expr (gimple
*stmt
, int spc
, dump_flags_t dump_flags
)
648 dump_flags
|= TDF_RHS_ONLY
;
650 pp_needs_newline (&pp
) = true;
651 pp_gimple_stmt_1 (&pp
, stmt
, spc
, dump_flags
);
654 = new optinfo_item (OPTINFO_ITEM_KIND_GIMPLE
, gimple_location (stmt
),
655 xstrdup (pp_formatted_text (&pp
)));
659 /* Dump gimple statement GS with SPC indentation spaces and
660 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled.
661 Do not terminate with a newline or semicolon. */
664 dump_context::dump_gimple_expr (dump_flags_t dump_kind
,
665 dump_flags_t extra_dump_flags
,
669 = make_item_for_dump_gimple_expr (gs
, spc
, dump_flags
| extra_dump_flags
);
670 emit_item (item
, dump_kind
);
672 if (optinfo_enabled_p ())
674 optinfo
&info
= ensure_pending_optinfo ();
675 info
.handle_dump_file_kind (dump_kind
);
676 info
.add_item (item
);
682 /* Similar to dump_gimple_expr, except additionally print source location. */
685 dump_context::dump_gimple_expr_loc (dump_flags_t dump_kind
,
686 const dump_location_t
&loc
,
687 dump_flags_t extra_dump_flags
,
691 dump_loc (dump_kind
, loc
);
692 dump_gimple_expr (dump_kind
, extra_dump_flags
, gs
, spc
);
695 /* Make an item for the given dump call, equivalent to print_generic_expr. */
697 static optinfo_item
*
698 make_item_for_dump_generic_expr (tree node
, dump_flags_t dump_flags
)
701 pp_needs_newline (&pp
) = true;
702 pp_translate_identifiers (&pp
) = false;
703 dump_generic_node (&pp
, node
, 0, dump_flags
, false);
705 location_t loc
= UNKNOWN_LOCATION
;
706 if (EXPR_HAS_LOCATION (node
))
707 loc
= EXPR_LOCATION (node
);
710 = new optinfo_item (OPTINFO_ITEM_KIND_TREE
, loc
,
711 xstrdup (pp_formatted_text (&pp
)));
715 /* Dump expression tree T using EXTRA_DUMP_FLAGS on dump streams if
716 DUMP_KIND is enabled. */
719 dump_context::dump_generic_expr (dump_flags_t dump_kind
,
720 dump_flags_t extra_dump_flags
,
724 = make_item_for_dump_generic_expr (t
, dump_flags
| extra_dump_flags
);
725 emit_item (item
, dump_kind
);
727 if (optinfo_enabled_p ())
729 optinfo
&info
= ensure_pending_optinfo ();
730 info
.handle_dump_file_kind (dump_kind
);
731 info
.add_item (item
);
738 /* Similar to dump_generic_expr, except additionally print the source
742 dump_context::dump_generic_expr_loc (dump_flags_t dump_kind
,
743 const dump_location_t
&loc
,
744 dump_flags_t extra_dump_flags
,
747 dump_loc (dump_kind
, loc
);
748 dump_generic_expr (dump_kind
, extra_dump_flags
, t
);
751 /* Make an item for the given dump call. */
753 static optinfo_item
*
754 make_item_for_dump_symtab_node (symtab_node
*node
)
756 location_t loc
= DECL_SOURCE_LOCATION (node
->decl
);
758 = new optinfo_item (OPTINFO_ITEM_KIND_SYMTAB_NODE
, loc
,
759 xstrdup (node
->dump_name ()));
763 /* dump_pretty_printer's ctor. */
765 dump_pretty_printer::dump_pretty_printer (dump_context
*context
,
766 dump_flags_t dump_kind
)
767 : pretty_printer (), m_context (context
), m_dump_kind (dump_kind
),
770 pp_format_decoder (this) = format_decoder_cb
;
773 /* Phase 3 of formatting; compare with pp_output_formatted_text.
775 Emit optinfo_item instances for the various formatted chunks from phases
776 1 and 2 (i.e. pp_format).
778 Some chunks may already have had their items built (during decode_format).
779 These chunks have been stashed into m_stashed_items; we emit them here.
781 For all other purely textual chunks, they are printed into
782 buffer->formatted_obstack, and then emitted as a textual optinfo_item.
783 This consolidates multiple adjacent text chunks into a single text
787 dump_pretty_printer::emit_items (optinfo
*dest
)
789 output_buffer
*buffer
= pp_buffer (this);
790 struct chunk_info
*chunk_array
= buffer
->cur_chunk_array
;
791 const char **args
= chunk_array
->args
;
793 gcc_assert (buffer
->obstack
== &buffer
->formatted_obstack
);
794 gcc_assert (buffer
->line_length
== 0);
796 unsigned stashed_item_idx
= 0;
797 for (unsigned chunk
= 0; args
[chunk
]; chunk
++)
799 if (stashed_item_idx
< m_stashed_items
.length ()
800 && args
[chunk
] == *m_stashed_items
[stashed_item_idx
].buffer_ptr
)
802 emit_any_pending_textual_chunks (dest
);
803 /* This chunk has a stashed item: use it. */
804 emit_item (m_stashed_items
[stashed_item_idx
++].item
, dest
);
807 /* This chunk is purely textual. Print it (to
808 buffer->formatted_obstack), so that we can consolidate adjacent
809 chunks into one textual optinfo_item. */
810 pp_string (this, args
[chunk
]);
813 emit_any_pending_textual_chunks (dest
);
815 /* Ensure that we consumed all of stashed_items. */
816 gcc_assert (stashed_item_idx
== m_stashed_items
.length ());
818 /* Deallocate the chunk structure and everything after it (i.e. the
819 associated series of formatted strings). */
820 buffer
->cur_chunk_array
= chunk_array
->prev
;
821 obstack_free (&buffer
->chunk_obstack
, chunk_array
);
824 /* Subroutine of dump_pretty_printer::emit_items
825 for consolidating multiple adjacent pure-text chunks into single
826 optinfo_items (in phase 3). */
829 dump_pretty_printer::emit_any_pending_textual_chunks (optinfo
*dest
)
831 gcc_assert (buffer
->obstack
== &buffer
->formatted_obstack
);
833 /* Don't emit an item if the pending text is empty. */
834 if (output_buffer_last_position_in_text (buffer
) == NULL
)
837 char *formatted_text
= xstrdup (pp_formatted_text (this));
839 = new optinfo_item (OPTINFO_ITEM_KIND_TEXT
, UNKNOWN_LOCATION
,
841 emit_item (item
, dest
);
843 /* Clear the pending text by unwinding formatted_text back to the start
844 of the buffer (without deallocating). */
845 obstack_free (&buffer
->formatted_obstack
,
846 buffer
->formatted_obstack
.object_base
);
849 /* Emit ITEM and take ownership of it. If DEST is non-NULL, add ITEM
850 to DEST; otherwise delete ITEM. */
853 dump_pretty_printer::emit_item (optinfo_item
*item
, optinfo
*dest
)
855 m_context
->emit_item (item
, m_dump_kind
);
857 dest
->add_item (item
);
862 /* Record that ITEM (generated in phase 2 of formatting) is to be used for
863 the chunk at BUFFER_PTR in phase 3 (by emit_items). */
866 dump_pretty_printer::stash_item (const char **buffer_ptr
, optinfo_item
*item
)
868 gcc_assert (buffer_ptr
);
871 m_stashed_items
.safe_push (stashed_item (buffer_ptr
, item
));
874 /* pp_format_decoder callback for dump_pretty_printer, and thus for
875 dump_printf and dump_printf_loc.
877 A wrapper around decode_format, for type-safety. */
880 dump_pretty_printer::format_decoder_cb (pretty_printer
*pp
, text_info
*text
,
881 const char *spec
, int /*precision*/,
882 bool /*wide*/, bool /*set_locus*/,
883 bool /*verbose*/, bool */
*quoted*/
,
884 const char **buffer_ptr
)
886 dump_pretty_printer
*opp
= static_cast <dump_pretty_printer
*> (pp
);
887 return opp
->decode_format (text
, spec
, buffer_ptr
);
890 /* Format decoder for dump_pretty_printer, and thus for dump_printf and
893 Supported format codes (in addition to the standard pretty_printer ones)
897 Equivalent to: dump_symtab_node (MSG_*, node)
899 Equivalent to: dump_gimple_expr (MSG_*, TDF_SLIM, stmt, 0)
901 Equivalent to: dump_gimple_stmt (MSG_*, TDF_SLIM, stmt, 0)
903 Equivalent to: dump_generic_expr (MSG_*, arg, TDF_SLIM).
905 TODO: add a format code that can handle (symtab_node*) *and* both
906 subclasses (presumably means teaching -Wformat about non-virtual
909 These format codes build optinfo_item instances, thus capturing metadata
910 about the arguments being dumped, as well as the textual output. */
913 dump_pretty_printer::decode_format (text_info
*text
, const char *spec
,
914 const char **buffer_ptr
)
916 /* Various format codes that imply making an optinfo_item and stashed it
917 for later use (to capture metadata, rather than plain text). */
922 cgraph_node
*node
= va_arg (*text
->args_ptr
, cgraph_node
*);
924 /* Make an item for the node, and stash it. */
925 optinfo_item
*item
= make_item_for_dump_symtab_node (node
);
926 stash_item (buffer_ptr
, item
);
932 gimple
*stmt
= va_arg (*text
->args_ptr
, gimple
*);
934 /* Make an item for the stmt, and stash it. */
935 optinfo_item
*item
= make_item_for_dump_gimple_expr (stmt
, 0, TDF_SLIM
);
936 stash_item (buffer_ptr
, item
);
942 gimple
*stmt
= va_arg (*text
->args_ptr
, gimple
*);
944 /* Make an item for the stmt, and stash it. */
945 optinfo_item
*item
= make_item_for_dump_gimple_stmt (stmt
, 0, TDF_SLIM
);
946 stash_item (buffer_ptr
, item
);
952 tree t
= va_arg (*text
->args_ptr
, tree
);
954 /* Make an item for the tree, and stash it. */
955 optinfo_item
*item
= make_item_for_dump_generic_expr (t
, TDF_SLIM
);
956 stash_item (buffer_ptr
, item
);
965 /* Output a formatted message using FORMAT on appropriate dump streams. */
968 dump_context::dump_printf_va (dump_flags_t dump_kind
, const char *format
,
971 dump_pretty_printer
pp (this, dump_kind
);
976 text
.format_spec
= format
;
978 /* Phases 1 and 2, using pp_format. */
979 pp_format (&pp
, &text
);
982 if (optinfo_enabled_p ())
984 optinfo
&info
= ensure_pending_optinfo ();
985 info
.handle_dump_file_kind (dump_kind
);
986 pp
.emit_items (&info
);
989 pp
.emit_items (NULL
);
992 /* Similar to dump_printf, except source location is also printed, and
993 dump location captured. */
996 dump_context::dump_printf_loc_va (dump_flags_t dump_kind
,
997 const dump_location_t
&loc
,
998 const char *format
, va_list *ap
)
1000 dump_loc (dump_kind
, loc
);
1001 dump_printf_va (dump_kind
, format
, ap
);
1004 /* Make an item for the given dump call, equivalent to print_dec. */
1006 template<unsigned int N
, typename C
>
1007 static optinfo_item
*
1008 make_item_for_dump_dec (const poly_int
<N
, C
> &value
)
1010 STATIC_ASSERT (poly_coeff_traits
<C
>::signedness
>= 0);
1011 signop sgn
= poly_coeff_traits
<C
>::signedness
? SIGNED
: UNSIGNED
;
1015 if (value
.is_constant ())
1016 pp_wide_int (&pp
, value
.coeffs
[0], sgn
);
1019 pp_character (&pp
, '[');
1020 for (unsigned int i
= 0; i
< N
; ++i
)
1022 pp_wide_int (&pp
, value
.coeffs
[i
], sgn
);
1023 pp_character (&pp
, i
== N
- 1 ? ']' : ',');
1028 = new optinfo_item (OPTINFO_ITEM_KIND_TEXT
, UNKNOWN_LOCATION
,
1029 xstrdup (pp_formatted_text (&pp
)));
1033 /* Output VALUE in decimal to appropriate dump streams. */
1035 template<unsigned int N
, typename C
>
1037 dump_context::dump_dec (dump_flags_t dump_kind
, const poly_int
<N
, C
> &value
)
1039 optinfo_item
*item
= make_item_for_dump_dec (value
);
1040 emit_item (item
, dump_kind
);
1042 if (optinfo_enabled_p ())
1044 optinfo
&info
= ensure_pending_optinfo ();
1045 info
.handle_dump_file_kind (dump_kind
);
1046 info
.add_item (item
);
1052 /* Output the name of NODE on appropriate dump streams. */
1055 dump_context::dump_symtab_node (dump_flags_t dump_kind
, symtab_node
*node
)
1057 optinfo_item
*item
= make_item_for_dump_symtab_node (node
);
1058 emit_item (item
, dump_kind
);
1060 if (optinfo_enabled_p ())
1062 optinfo
&info
= ensure_pending_optinfo ();
1063 info
.handle_dump_file_kind (dump_kind
);
1064 info
.add_item (item
);
1070 /* Get the current dump scope-nesting depth.
1071 For use by -fopt-info (for showing nesting via indentation). */
1074 dump_context::get_scope_depth () const
1076 return m_scope_depth
;
1079 /* Push a nested dump scope.
1080 Increment the scope depth.
1081 Print "=== NAME ===\n" to the dumpfile, if any, and to the -fopt-info
1082 destination, if any.
1083 Emit a "scope" optinfo if optinfos are enabled. */
1086 dump_context::begin_scope (const char *name
, const dump_location_t
&loc
)
1090 if (dump_file
&& apply_dump_filter_p (MSG_NOTE
, pflags
))
1091 ::dump_loc (MSG_NOTE
, dump_file
, loc
.get_location_t ());
1093 if (alt_dump_file
&& apply_dump_filter_p (MSG_NOTE
, alt_flags
))
1094 ::dump_loc (MSG_NOTE
, alt_dump_file
, loc
.get_location_t ());
1096 /* Support for temp_dump_context in selftests. */
1097 if (m_test_pp
&& apply_dump_filter_p (MSG_NOTE
, m_test_pp_flags
))
1098 ::dump_loc (MSG_NOTE
, m_test_pp
, loc
.get_location_t ());
1101 pp_printf (&pp
, "=== %s ===\n", name
);
1103 = new optinfo_item (OPTINFO_ITEM_KIND_TEXT
, UNKNOWN_LOCATION
,
1104 xstrdup (pp_formatted_text (&pp
)));
1105 emit_item (item
, MSG_NOTE
);
1107 if (optinfo_enabled_p ())
1109 optinfo
&info
= begin_next_optinfo (loc
);
1110 info
.m_kind
= OPTINFO_KIND_SCOPE
;
1111 info
.add_item (item
);
1117 /* Pop a nested dump scope. */
1120 dump_context::end_scope ()
1124 optimization_records_maybe_pop_dump_scope ();
1127 /* Return the optinfo currently being accumulated, creating one if
1131 dump_context::ensure_pending_optinfo ()
1134 return begin_next_optinfo (dump_location_t (dump_user_location_t ()));
1138 /* Start a new optinfo and return it, ending any optinfo that was already
1142 dump_context::begin_next_optinfo (const dump_location_t
&loc
)
1145 gcc_assert (m_pending
== NULL
);
1146 m_pending
= new optinfo (loc
, OPTINFO_KIND_NOTE
, current_pass
);
1150 /* End any optinfo that has been accumulated within this context; emitting
1151 it to any destinations as appropriate, such as optimization records. */
1154 dump_context::end_any_optinfo ()
1162 /* Emit ITEM to all item destinations (those that don't require
1163 consolidation into optinfo instances). */
1166 dump_context::emit_item (optinfo_item
*item
, dump_flags_t dump_kind
)
1168 if (dump_file
&& apply_dump_filter_p (dump_kind
, pflags
))
1169 fprintf (dump_file
, "%s", item
->get_text ());
1171 if (alt_dump_file
&& apply_dump_filter_p (dump_kind
, alt_flags
))
1172 fprintf (alt_dump_file
, "%s", item
->get_text ());
1174 /* Support for temp_dump_context in selftests. */
1175 if (m_test_pp
&& apply_dump_filter_p (dump_kind
, m_test_pp_flags
))
1176 pp_string (m_test_pp
, item
->get_text ());
1179 /* The current singleton dump_context, and its default. */
1181 dump_context
*dump_context::s_current
= &dump_context::s_default
;
1182 dump_context
dump_context::s_default
;
1184 /* Implementation of dump_* API calls, calling into dump_context
1185 member functions. */
1187 /* Calls to the dump_* functions do non-trivial work, so they ought
1189 if (dump_enabled_p ())
1190 Assert that they are guarded, and, if assertions are disabled,
1191 bail out if the calls weren't properly guarded. */
1193 #define VERIFY_DUMP_ENABLED_P \
1195 gcc_assert (dump_enabled_p ()); \
1196 if (!dump_enabled_p ()) \
1200 /* Dump gimple statement GS with SPC indentation spaces and
1201 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled. */
1204 dump_gimple_stmt (dump_flags_t dump_kind
, dump_flags_t extra_dump_flags
,
1205 gimple
*gs
, int spc
)
1207 VERIFY_DUMP_ENABLED_P
;
1208 dump_context::get ().dump_gimple_stmt (dump_kind
, extra_dump_flags
, gs
, spc
);
1211 /* Similar to dump_gimple_stmt, except additionally print source location. */
1214 dump_gimple_stmt_loc (dump_flags_t dump_kind
, const dump_location_t
&loc
,
1215 dump_flags_t extra_dump_flags
, gimple
*gs
, int spc
)
1217 VERIFY_DUMP_ENABLED_P
;
1218 dump_context::get ().dump_gimple_stmt_loc (dump_kind
, loc
, extra_dump_flags
,
1222 /* Dump gimple statement GS with SPC indentation spaces and
1223 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled.
1224 Do not terminate with a newline or semicolon. */
1227 dump_gimple_expr (dump_flags_t dump_kind
, dump_flags_t extra_dump_flags
,
1228 gimple
*gs
, int spc
)
1230 VERIFY_DUMP_ENABLED_P
;
1231 dump_context::get ().dump_gimple_expr (dump_kind
, extra_dump_flags
, gs
, spc
);
1234 /* Similar to dump_gimple_expr, except additionally print source location. */
1237 dump_gimple_expr_loc (dump_flags_t dump_kind
, const dump_location_t
&loc
,
1238 dump_flags_t extra_dump_flags
, gimple
*gs
, int spc
)
1240 VERIFY_DUMP_ENABLED_P
;
1241 dump_context::get ().dump_gimple_expr_loc (dump_kind
, loc
, extra_dump_flags
,
1245 /* Dump expression tree T using EXTRA_DUMP_FLAGS on dump streams if
1246 DUMP_KIND is enabled. */
1249 dump_generic_expr (dump_flags_t dump_kind
, dump_flags_t extra_dump_flags
,
1252 VERIFY_DUMP_ENABLED_P
;
1253 dump_context::get ().dump_generic_expr (dump_kind
, extra_dump_flags
, t
);
1256 /* Similar to dump_generic_expr, except additionally print the source
1260 dump_generic_expr_loc (dump_flags_t dump_kind
, const dump_location_t
&loc
,
1261 dump_flags_t extra_dump_flags
, tree t
)
1263 VERIFY_DUMP_ENABLED_P
;
1264 dump_context::get ().dump_generic_expr_loc (dump_kind
, loc
, extra_dump_flags
,
1268 /* Output a formatted message using FORMAT on appropriate dump streams. */
1271 dump_printf (dump_flags_t dump_kind
, const char *format
, ...)
1273 VERIFY_DUMP_ENABLED_P
;
1275 va_start (ap
, format
);
1276 dump_context::get ().dump_printf_va (dump_kind
, format
, &ap
);
1280 /* Similar to dump_printf, except source location is also printed, and
1281 dump location captured. */
1284 dump_printf_loc (dump_flags_t dump_kind
, const dump_location_t
&loc
,
1285 const char *format
, ...)
1287 VERIFY_DUMP_ENABLED_P
;
1289 va_start (ap
, format
);
1290 dump_context::get ().dump_printf_loc_va (dump_kind
, loc
, format
, &ap
);
1294 /* Output VALUE in decimal to appropriate dump streams. */
1296 template<unsigned int N
, typename C
>
1298 dump_dec (dump_flags_t dump_kind
, const poly_int
<N
, C
> &value
)
1300 VERIFY_DUMP_ENABLED_P
;
1301 dump_context::get ().dump_dec (dump_kind
, value
);
1304 template void dump_dec (dump_flags_t
, const poly_uint16
&);
1305 template void dump_dec (dump_flags_t
, const poly_int64
&);
1306 template void dump_dec (dump_flags_t
, const poly_uint64
&);
1307 template void dump_dec (dump_flags_t
, const poly_offset_int
&);
1308 template void dump_dec (dump_flags_t
, const poly_widest_int
&);
1311 dump_dec (dump_flags_t dump_kind
, const poly_wide_int
&value
, signop sgn
)
1313 VERIFY_DUMP_ENABLED_P
;
1315 && dump_context::get ().apply_dump_filter_p (dump_kind
, pflags
))
1316 print_dec (value
, dump_file
, sgn
);
1319 && dump_context::get ().apply_dump_filter_p (dump_kind
, alt_flags
))
1320 print_dec (value
, alt_dump_file
, sgn
);
1323 /* Output VALUE in hexadecimal to appropriate dump streams. */
1326 dump_hex (dump_flags_t dump_kind
, const poly_wide_int
&value
)
1328 VERIFY_DUMP_ENABLED_P
;
1330 && dump_context::get ().apply_dump_filter_p (dump_kind
, pflags
))
1331 print_hex (value
, dump_file
);
1334 && dump_context::get ().apply_dump_filter_p (dump_kind
, alt_flags
))
1335 print_hex (value
, alt_dump_file
);
1338 /* Emit and delete the currently pending optinfo, if there is one,
1339 without the caller needing to know about class dump_context. */
1342 dumpfile_ensure_any_optinfo_are_flushed ()
1344 dump_context::get().end_any_optinfo ();
1347 /* Output the name of NODE on appropriate dump streams. */
1350 dump_symtab_node (dump_flags_t dump_kind
, symtab_node
*node
)
1352 VERIFY_DUMP_ENABLED_P
;
1353 dump_context::get ().dump_symtab_node (dump_kind
, node
);
1356 /* Get the current dump scope-nesting depth.
1357 For use by -fopt-info (for showing nesting via indentation). */
1360 get_dump_scope_depth ()
1362 return dump_context::get ().get_scope_depth ();
1365 /* Push a nested dump scope.
1366 Print "=== NAME ===\n" to the dumpfile, if any, and to the -fopt-info
1367 destination, if any.
1368 Emit a "scope" opinfo if optinfos are enabled.
1369 Increment the scope depth. */
1372 dump_begin_scope (const char *name
, const dump_location_t
&loc
)
1374 dump_context::get ().begin_scope (name
, loc
);
1377 /* Pop a nested dump scope. */
1382 dump_context::get ().end_scope ();
1385 /* Start a dump for PHASE. Store user-supplied dump flags in
1386 *FLAG_PTR. Return the number of streams opened. Set globals
1387 DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and
1388 set dump_flags appropriately for both pass dump stream and
1389 -fopt-info stream. */
1393 dump_start (int phase
, dump_flags_t
*flag_ptr
)
1397 struct dump_file_info
*dfi
;
1399 if (phase
== TDI_none
|| !dump_phase_enabled_p (phase
))
1402 dfi
= get_dump_file_info (phase
);
1403 name
= get_dump_file_name (phase
);
1406 stream
= dump_open (name
, dfi
->pstate
< 0);
1413 dfi
->pstream
= stream
;
1414 set_dump_file (dfi
->pstream
);
1415 /* Initialize current dump flags. */
1416 pflags
= dfi
->pflags
;
1419 stream
= dump_open_alternate_stream (dfi
);
1422 dfi
->alt_stream
= stream
;
1424 set_alt_dump_file (dfi
->alt_stream
);
1425 /* Initialize current -fopt-info flags. */
1426 alt_flags
= dfi
->alt_flags
;
1430 *flag_ptr
= dfi
->pflags
;
1435 /* Finish a tree dump for PHASE and close associated dump streams. Also
1436 reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS. */
1440 dump_finish (int phase
)
1442 struct dump_file_info
*dfi
;
1446 dfi
= get_dump_file_info (phase
);
1447 if (dfi
->pstream
&& dfi
->pstream
!= stdout
&& dfi
->pstream
!= stderr
)
1448 fclose (dfi
->pstream
);
1450 if (dfi
->alt_stream
&& dfi
->alt_stream
!= stdout
&& dfi
->alt_stream
!= stderr
)
1451 fclose (dfi
->alt_stream
);
1453 dfi
->alt_stream
= NULL
;
1454 dfi
->pstream
= NULL
;
1455 set_dump_file (NULL
);
1456 set_alt_dump_file (NULL
);
1457 dump_flags
= TDF_NONE
;
1458 alt_flags
= TDF_NONE
;
1462 /* Begin a tree dump for PHASE. Stores any user supplied flag in
1463 *FLAG_PTR and returns a stream to write to. If the dump is not
1464 enabled, returns NULL.
1465 PART can be used for dump files which should be split to multiple
1466 parts. PART == -1 indicates dump file with no parts.
1467 If PART is -1, multiple calls will reopen and append to the dump file. */
1470 dump_begin (int phase
, dump_flags_t
*flag_ptr
, int part
)
1472 return g
->get_dumps ()->dump_begin (phase
, flag_ptr
, part
);
1477 dump_begin (int phase
, dump_flags_t
*flag_ptr
, int part
)
1480 struct dump_file_info
*dfi
;
1483 if (phase
== TDI_none
|| !dump_phase_enabled_p (phase
))
1486 name
= get_dump_file_name (phase
, part
);
1489 dfi
= get_dump_file_info (phase
);
1491 /* We do not support re-opening of dump files with parts. This would require
1492 tracking pstate per part of the dump file. */
1493 stream
= dump_open (name
, part
!= -1 || dfi
->pstate
< 0);
1499 *flag_ptr
= dfi
->pflags
;
1501 /* Initialize current flags */
1502 pflags
= dfi
->pflags
;
1506 /* Returns nonzero if dump PHASE is enabled for at least one stream.
1507 If PHASE is TDI_tree_all, return nonzero if any dump is enabled for
1512 dump_phase_enabled_p (int phase
) const
1514 if (phase
== TDI_tree_all
)
1517 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1518 if (dump_files
[i
].pstate
|| dump_files
[i
].alt_state
)
1520 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1521 if (m_extra_dump_files
[i
].pstate
|| m_extra_dump_files
[i
].alt_state
)
1527 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
1528 return dfi
->pstate
|| dfi
->alt_state
;
1532 /* Returns nonzero if tree dump PHASE has been initialized. */
1536 dump_initialized_p (int phase
) const
1538 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
1539 return dfi
->pstate
> 0 || dfi
->alt_state
> 0;
1542 /* Returns the switch name of PHASE. */
1545 dump_flag_name (int phase
)
1547 return g
->get_dumps ()->dump_flag_name (phase
);
1552 dump_flag_name (int phase
) const
1554 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
1558 /* Handle -fdump-* and -fopt-info for a pass added after
1559 command-line options are parsed (those from plugins and
1560 those from backends).
1562 Because the registration of plugin/backend passes happens after the
1563 command-line options are parsed, the options that specify single
1564 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1565 passes. Therefore we currently can only enable dumping of
1566 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1567 are specified. This is done here.
1569 Similarly, the saved -fopt-info options are wired up to the new pass. */
1572 gcc::dump_manager::register_pass (opt_pass
*pass
)
1576 register_one_dump_file (pass
);
1578 dump_file_info
*pass_dfi
= get_dump_file_info (pass
->static_pass_number
);
1579 gcc_assert (pass_dfi
);
1581 enum tree_dump_index tdi
;
1582 if (pass
->type
== SIMPLE_IPA_PASS
1583 || pass
->type
== IPA_PASS
)
1585 else if (pass
->type
== GIMPLE_PASS
)
1589 const dump_file_info
*tdi_dfi
= get_dump_file_info (tdi
);
1590 gcc_assert (tdi_dfi
);
1592 /* Check if dump-all flag is specified. */
1593 if (tdi_dfi
->pstate
)
1595 pass_dfi
->pstate
= tdi_dfi
->pstate
;
1596 pass_dfi
->pflags
= tdi_dfi
->pflags
;
1599 update_dfi_for_opt_info (pass_dfi
);
1602 /* Finish a tree dump for PHASE. STREAM is the stream created by
1606 dump_end (int phase ATTRIBUTE_UNUSED
, FILE *stream
)
1608 if (stream
!= stderr
&& stream
!= stdout
)
1612 /* Enable all tree dumps with FLAGS on FILENAME. Return number of
1613 enabled tree dumps. */
1617 dump_enable_all (dump_kind dkind
, dump_flags_t flags
, const char *filename
)
1622 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1624 if (dump_files
[i
].dkind
== dkind
)
1626 const char *old_filename
= dump_files
[i
].pfilename
;
1627 dump_files
[i
].pstate
= -1;
1628 dump_files
[i
].pflags
|= flags
;
1630 /* Override the existing filename. */
1633 dump_files
[i
].pfilename
= xstrdup (filename
);
1634 /* Since it is a command-line provided file, which is
1635 common to all the phases, use it in append mode. */
1636 dump_files
[i
].pstate
= 1;
1638 if (old_filename
&& filename
!= old_filename
)
1639 free (CONST_CAST (char *, old_filename
));
1643 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1645 if (m_extra_dump_files
[i
].dkind
== dkind
)
1647 const char *old_filename
= m_extra_dump_files
[i
].pfilename
;
1648 m_extra_dump_files
[i
].pstate
= -1;
1649 m_extra_dump_files
[i
].pflags
|= flags
;
1651 /* Override the existing filename. */
1654 m_extra_dump_files
[i
].pfilename
= xstrdup (filename
);
1655 /* Since it is a command-line provided file, which is
1656 common to all the phases, use it in append mode. */
1657 m_extra_dump_files
[i
].pstate
= 1;
1659 if (old_filename
&& filename
!= old_filename
)
1660 free (CONST_CAST (char *, old_filename
));
1667 /* Enable -fopt-info dumps on all dump files matching OPTGROUP_FLAGS.
1668 Enable dumps with FLAGS on FILENAME. Return the number of enabled
1673 opt_info_enable_passes (optgroup_flags_t optgroup_flags
, dump_flags_t flags
,
1674 const char *filename
)
1678 m_optgroup_flags
= optgroup_flags
;
1679 m_optinfo_flags
= flags
;
1680 m_optinfo_filename
= xstrdup (filename
);
1682 for (size_t i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1683 if (update_dfi_for_opt_info (&dump_files
[i
]))
1686 for (size_t i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1687 if (update_dfi_for_opt_info (&m_extra_dump_files
[i
]))
1693 /* Use the saved -fopt-info options to update DFI.
1694 Return true if the dump is enabled. */
1697 gcc::dump_manager::update_dfi_for_opt_info (dump_file_info
*dfi
) const
1701 if (!(dfi
->optgroup_flags
& m_optgroup_flags
))
1704 const char *old_filename
= dfi
->alt_filename
;
1705 /* Since this file is shared among different passes, it
1706 should be opened in append mode. */
1708 dfi
->alt_flags
|= m_optinfo_flags
;
1709 /* Override the existing filename. */
1710 if (m_optinfo_filename
)
1711 dfi
->alt_filename
= xstrdup (m_optinfo_filename
);
1712 if (old_filename
&& m_optinfo_filename
!= old_filename
)
1713 free (CONST_CAST (char *, old_filename
));
1718 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1719 relevant details in the dump_files array. */
1723 dump_switch_p_1 (const char *arg
, struct dump_file_info
*dfi
, bool doglob
)
1725 const char *option_value
;
1729 if (doglob
&& !dfi
->glob
)
1732 option_value
= skip_leading_substring (arg
, doglob
? dfi
->glob
: dfi
->swtch
);
1736 if (*option_value
&& *option_value
!= '-' && *option_value
!= '=')
1741 /* Retain "user-facing" and "internals" messages, but filter out
1742 those from an opt_problem being re-emitted at the top level
1743 (MSG_PRIORITY_REEMITTED), so as to avoid duplicate messages
1744 messing up scan-tree-dump-times" in DejaGnu tests. */
1745 flags
= MSG_PRIORITY_USER_FACING
| MSG_PRIORITY_INTERNALS
;
1749 const struct kv_pair
<dump_flags_t
> *option_ptr
;
1750 const char *end_ptr
;
1756 end_ptr
= strchr (ptr
, '-');
1757 eq_ptr
= strchr (ptr
, '=');
1759 if (eq_ptr
&& !end_ptr
)
1763 end_ptr
= ptr
+ strlen (ptr
);
1764 length
= end_ptr
- ptr
;
1766 for (option_ptr
= dump_options
; option_ptr
->name
; option_ptr
++)
1767 if (strlen (option_ptr
->name
) == length
1768 && !memcmp (option_ptr
->name
, ptr
, length
))
1770 flags
|= option_ptr
->value
;
1776 /* Interpret rest of the argument as a dump filename. This
1777 filename overrides other command line filenames. */
1779 free (CONST_CAST (char *, dfi
->pfilename
));
1780 dfi
->pfilename
= xstrdup (ptr
+ 1);
1784 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1785 length
, ptr
, dfi
->swtch
);
1791 dfi
->pflags
|= flags
;
1793 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1795 if (dfi
->suffix
== NULL
)
1796 dump_enable_all (dfi
->dkind
, dfi
->pflags
, dfi
->pfilename
);
1803 dump_switch_p (const char *arg
)
1808 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1809 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], false);
1811 /* Don't glob if we got a hit already */
1813 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1814 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], true);
1816 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1817 any
|= dump_switch_p_1 (arg
, &m_extra_dump_files
[i
], false);
1820 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1821 any
|= dump_switch_p_1 (arg
, &m_extra_dump_files
[i
], true);
1827 /* Parse ARG as a -fopt-info switch and store flags, optgroup_flags
1828 and filename. Return non-zero if it is a recognized switch. */
1831 opt_info_switch_p_1 (const char *arg
, dump_flags_t
*flags
,
1832 optgroup_flags_t
*optgroup_flags
, char **filename
)
1834 const char *option_value
;
1842 /* Default to filtering out "internals" messages, and retaining
1843 "user-facing" messages, and those from an opt_problem being
1844 re-emitted at the top level. */
1845 *flags
= MSG_PRIORITY_USER_FACING
| MSG_PRIORITY_REEMITTED
;
1847 *optgroup_flags
= OPTGROUP_NONE
;
1850 return 1; /* Handle '-fopt-info' without any additional options. */
1854 const char *end_ptr
;
1860 end_ptr
= strchr (ptr
, '-');
1861 eq_ptr
= strchr (ptr
, '=');
1863 if (eq_ptr
&& !end_ptr
)
1867 end_ptr
= ptr
+ strlen (ptr
);
1868 length
= end_ptr
- ptr
;
1870 for (const kv_pair
<dump_flags_t
> *option_ptr
= optinfo_verbosity_options
;
1871 option_ptr
->name
; option_ptr
++)
1872 if (strlen (option_ptr
->name
) == length
1873 && !memcmp (option_ptr
->name
, ptr
, length
))
1875 *flags
|= option_ptr
->value
;
1879 for (const kv_pair
<optgroup_flags_t
> *option_ptr
= optgroup_options
;
1880 option_ptr
->name
; option_ptr
++)
1881 if (strlen (option_ptr
->name
) == length
1882 && !memcmp (option_ptr
->name
, ptr
, length
))
1884 *optgroup_flags
|= option_ptr
->value
;
1890 /* Interpret rest of the argument as a dump filename. This
1891 filename overrides other command line filenames. */
1892 *filename
= xstrdup (ptr
+ 1);
1897 warning (0, "unknown option %q.*s in %<-fopt-info-%s%>",
1908 /* Return non-zero if ARG is a recognized switch for
1909 -fopt-info. Return zero otherwise. */
1912 opt_info_switch_p (const char *arg
)
1915 optgroup_flags_t optgroup_flags
;
1917 static char *file_seen
= NULL
;
1918 gcc::dump_manager
*dumps
= g
->get_dumps ();
1920 if (!opt_info_switch_p_1 (arg
, &flags
, &optgroup_flags
, &filename
))
1924 filename
= xstrdup ("stderr");
1926 /* Bail out if a different filename has been specified. */
1927 if (file_seen
&& strcmp (file_seen
, filename
))
1929 warning (0, "ignoring possibly conflicting option %<-fopt-info-%s%>",
1934 file_seen
= xstrdup (filename
);
1935 if (!(flags
& MSG_ALL_KINDS
))
1936 flags
|= MSG_OPTIMIZED_LOCATIONS
;
1937 if (!optgroup_flags
)
1938 optgroup_flags
= OPTGROUP_ALL
;
1940 return dumps
->opt_info_enable_passes (optgroup_flags
, flags
, filename
);
1943 /* Print basic block on the dump streams. */
1946 dump_basic_block (dump_flags_t dump_kind
, basic_block bb
, int indent
)
1949 && dump_context::get ().apply_dump_filter_p (dump_kind
, pflags
))
1950 dump_bb (dump_file
, bb
, indent
, TDF_DETAILS
);
1952 && dump_context::get ().apply_dump_filter_p (dump_kind
, alt_flags
))
1953 dump_bb (alt_dump_file
, bb
, indent
, TDF_DETAILS
);
1956 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
1959 dump_function (int phase
, tree fn
)
1964 stream
= dump_begin (phase
, &flags
);
1967 dump_function_to_file (fn
, stream
, flags
);
1968 dump_end (phase
, stream
);
1972 /* Print information from the combine pass on dump_file. */
1975 print_combine_total_stats (void)
1978 dump_combine_total_stats (dump_file
);
1981 /* Enable RTL dump for all the RTL passes. */
1984 enable_rtl_dump_file (void)
1986 gcc::dump_manager
*dumps
= g
->get_dumps ();
1988 dumps
->dump_enable_all (DK_rtl
, dump_flags_t (TDF_DETAILS
) | TDF_BLOCKS
,
1990 return num_enabled
> 0;
1995 namespace selftest
{
1997 /* temp_dump_context's ctor. Temporarily override the dump_context
1998 (to forcibly enable optinfo-generation). */
2000 temp_dump_context::temp_dump_context (bool forcibly_enable_optinfo
,
2001 bool forcibly_enable_dumping
,
2002 dump_flags_t test_pp_flags
)
2004 m_saved (&dump_context ().get ())
2006 dump_context::s_current
= &m_context
;
2007 m_context
.m_forcibly_enable_optinfo
= forcibly_enable_optinfo
;
2008 /* Conditionally enable the test dump, so that we can verify both the
2009 dump_enabled_p and the !dump_enabled_p cases in selftests. */
2010 if (forcibly_enable_dumping
)
2012 m_context
.m_test_pp
= &m_pp
;
2013 m_context
.m_test_pp_flags
= test_pp_flags
;
2016 dump_context::get ().refresh_dumps_are_enabled ();
2019 /* temp_dump_context's dtor. Restore the saved dump_context. */
2021 temp_dump_context::~temp_dump_context ()
2023 dump_context::s_current
= m_saved
;
2025 dump_context::get ().refresh_dumps_are_enabled ();
2028 /* 0-terminate the text dumped so far, and return it. */
2031 temp_dump_context::get_dumped_text ()
2033 return pp_formatted_text (&m_pp
);
2036 /* Verify that the dump_location_t constructors capture the source location
2037 at which they were called (provided that the build compiler is sufficiently
2041 test_impl_location ()
2043 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
2046 dump_location_t loc
;
2047 const int expected_line
= __LINE__
- 1;
2048 ASSERT_STR_CONTAINS (loc
.get_impl_location ().m_file
, "dumpfile.c");
2049 ASSERT_EQ (loc
.get_impl_location ().m_line
, expected_line
);
2052 /* Constructing from a gimple. */
2054 dump_location_t
loc ((gimple
*)NULL
);
2055 const int expected_line
= __LINE__
- 1;
2056 ASSERT_STR_CONTAINS (loc
.get_impl_location ().m_file
, "dumpfile.c");
2057 ASSERT_EQ (loc
.get_impl_location ().m_line
, expected_line
);
2060 /* Constructing from an rtx_insn. */
2062 dump_location_t
loc ((rtx_insn
*)NULL
);
2063 const int expected_line
= __LINE__
- 1;
2064 ASSERT_STR_CONTAINS (loc
.get_impl_location ().m_file
, "dumpfile.c");
2065 ASSERT_EQ (loc
.get_impl_location ().m_line
, expected_line
);
2070 /* Verify that the text dumped so far in CONTEXT equals
2071 EXPECTED_TEXT, using LOC for the location of any failure.
2072 As a side-effect, the internal buffer is 0-terminated. */
2075 verify_dumped_text (const location
&loc
,
2076 temp_dump_context
*context
,
2077 const char *expected_text
)
2079 gcc_assert (context
);
2080 ASSERT_STREQ_AT (loc
, context
->get_dumped_text (),
2084 /* Verify that ITEM has the expected values. */
2087 verify_item (const location
&loc
,
2088 const optinfo_item
*item
,
2089 enum optinfo_item_kind expected_kind
,
2090 location_t expected_location
,
2091 const char *expected_text
)
2093 ASSERT_EQ_AT (loc
, item
->get_kind (), expected_kind
);
2094 ASSERT_EQ_AT (loc
, item
->get_location (), expected_location
);
2095 ASSERT_STREQ_AT (loc
, item
->get_text (), expected_text
);
2098 /* Verify that calls to the dump_* API are captured and consolidated into
2099 optimization records. */
2102 test_capture_of_dump_calls (const line_table_case
&case_
)
2104 /* Generate a location_t for testing. */
2105 line_table_test
ltt (case_
);
2106 linemap_add (line_table
, LC_ENTER
, false, "test.txt", 0);
2107 linemap_line_start (line_table
, 5, 100);
2108 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
2109 location_t decl_loc
= linemap_position_for_column (line_table
, 8);
2110 location_t stmt_loc
= linemap_position_for_column (line_table
, 10);
2111 if (stmt_loc
> LINE_MAP_MAX_LOCATION_WITH_COLS
)
2114 dump_location_t loc
= dump_location_t::from_location_t (stmt_loc
);
2116 gimple
*stmt
= gimple_build_return (NULL
);
2117 gimple_set_location (stmt
, stmt_loc
);
2119 tree test_decl
= build_decl (decl_loc
, FUNCTION_DECL
,
2120 get_identifier ("test_decl"),
2121 build_function_type_list (void_type_node
,
2124 symbol_table_test tmp_symtab
;
2126 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
2129 /* Run all tests twice, with and then without optinfo enabled, to ensure
2130 that immediate destinations vs optinfo-based destinations both
2131 work, independently of each other, with no leaks. */
2132 for (int i
= 0 ; i
< 2; i
++)
2134 bool with_optinfo
= (i
== 0);
2136 /* Test of dump_printf. */
2138 temp_dump_context
tmp (with_optinfo
, true,
2139 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2140 dump_printf (MSG_NOTE
, "int: %i str: %s", 42, "foo");
2142 ASSERT_DUMPED_TEXT_EQ (tmp
, "int: 42 str: foo");
2145 optinfo
*info
= tmp
.get_pending_optinfo ();
2146 ASSERT_TRUE (info
!= NULL
);
2147 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2148 ASSERT_EQ (info
->num_items (), 1);
2149 ASSERT_IS_TEXT (info
->get_item (0), "int: 42 str: foo");
2153 /* Test of dump_printf with %T. */
2155 temp_dump_context
tmp (with_optinfo
, true,
2156 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2157 dump_printf (MSG_NOTE
, "tree: %T", integer_zero_node
);
2159 ASSERT_DUMPED_TEXT_EQ (tmp
, "tree: 0");
2162 optinfo
*info
= tmp
.get_pending_optinfo ();
2163 ASSERT_TRUE (info
!= NULL
);
2164 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2165 ASSERT_EQ (info
->num_items (), 2);
2166 ASSERT_IS_TEXT (info
->get_item (0), "tree: ");
2167 ASSERT_IS_TREE (info
->get_item (1), UNKNOWN_LOCATION
, "0");
2171 /* Test of dump_printf with %E. */
2173 temp_dump_context
tmp (with_optinfo
, true,
2174 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2175 dump_printf (MSG_NOTE
, "gimple: %E", stmt
);
2177 ASSERT_DUMPED_TEXT_EQ (tmp
, "gimple: return;");
2180 optinfo
*info
= tmp
.get_pending_optinfo ();
2181 ASSERT_TRUE (info
!= NULL
);
2182 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2183 ASSERT_EQ (info
->num_items (), 2);
2184 ASSERT_IS_TEXT (info
->get_item (0), "gimple: ");
2185 ASSERT_IS_GIMPLE (info
->get_item (1), stmt_loc
, "return;");
2189 /* Test of dump_printf with %G. */
2191 temp_dump_context
tmp (with_optinfo
, true,
2192 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2193 dump_printf (MSG_NOTE
, "gimple: %G", stmt
);
2195 ASSERT_DUMPED_TEXT_EQ (tmp
, "gimple: return;\n");
2198 optinfo
*info
= tmp
.get_pending_optinfo ();
2199 ASSERT_TRUE (info
!= NULL
);
2200 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2201 ASSERT_EQ (info
->num_items (), 2);
2202 ASSERT_IS_TEXT (info
->get_item (0), "gimple: ");
2203 ASSERT_IS_GIMPLE (info
->get_item (1), stmt_loc
, "return;\n");
2207 /* Test of dump_printf with %C. */
2209 temp_dump_context
tmp (with_optinfo
, true,
2210 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2211 dump_printf (MSG_NOTE
, "node: %C", node
);
2213 ASSERT_DUMPED_TEXT_EQ (tmp
, "node: test_decl/0");
2216 optinfo
*info
= tmp
.get_pending_optinfo ();
2217 ASSERT_TRUE (info
!= NULL
);
2218 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2219 ASSERT_EQ (info
->num_items (), 2);
2220 ASSERT_IS_TEXT (info
->get_item (0), "node: ");
2221 ASSERT_IS_SYMTAB_NODE (info
->get_item (1), decl_loc
, "test_decl/0");
2225 /* dump_print_loc with multiple format codes. This tests various
2227 - intermingling of text, format codes handled by the base
2228 pretty_printer, and dump-specific format codes
2229 - multiple dump-specific format codes: some consecutive, others
2230 separated by text, trailing text after the final one. */
2232 temp_dump_context
tmp (with_optinfo
, true,
2233 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2234 dump_printf_loc (MSG_NOTE
, loc
, "before %T and %T"
2235 " %i consecutive %E%E after\n",
2236 integer_zero_node
, test_decl
, 42, stmt
, stmt
);
2238 ASSERT_DUMPED_TEXT_EQ (tmp
,
2239 "test.txt:5:10: note: before 0 and test_decl"
2240 " 42 consecutive return;return; after\n");
2243 optinfo
*info
= tmp
.get_pending_optinfo ();
2244 ASSERT_TRUE (info
!= NULL
);
2245 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2246 ASSERT_EQ (info
->num_items (), 8);
2247 ASSERT_IS_TEXT (info
->get_item (0), "before ");
2248 ASSERT_IS_TREE (info
->get_item (1), UNKNOWN_LOCATION
, "0");
2249 ASSERT_IS_TEXT (info
->get_item (2), " and ");
2250 ASSERT_IS_TREE (info
->get_item (3), UNKNOWN_LOCATION
, "test_decl");
2251 ASSERT_IS_TEXT (info
->get_item (4), " 42 consecutive ");
2252 ASSERT_IS_GIMPLE (info
->get_item (5), stmt_loc
, "return;");
2253 ASSERT_IS_GIMPLE (info
->get_item (6), stmt_loc
, "return;");
2254 ASSERT_IS_TEXT (info
->get_item (7), " after\n");
2258 /* Tree, via dump_generic_expr. */
2260 temp_dump_context
tmp (with_optinfo
, true,
2261 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2262 dump_printf_loc (MSG_NOTE
, loc
, "test of tree: ");
2263 dump_generic_expr (MSG_NOTE
, TDF_SLIM
, integer_zero_node
);
2265 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: test of tree: 0");
2268 optinfo
*info
= tmp
.get_pending_optinfo ();
2269 ASSERT_TRUE (info
!= NULL
);
2270 ASSERT_EQ (info
->get_location_t (), stmt_loc
);
2271 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2272 ASSERT_EQ (info
->num_items (), 2);
2273 ASSERT_IS_TEXT (info
->get_item (0), "test of tree: ");
2274 ASSERT_IS_TREE (info
->get_item (1), UNKNOWN_LOCATION
, "0");
2278 /* Tree, via dump_generic_expr_loc. */
2280 temp_dump_context
tmp (with_optinfo
, true,
2281 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2282 dump_generic_expr_loc (MSG_NOTE
, loc
, TDF_SLIM
, integer_one_node
);
2284 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: 1");
2287 optinfo
*info
= tmp
.get_pending_optinfo ();
2288 ASSERT_TRUE (info
!= NULL
);
2289 ASSERT_EQ (info
->get_location_t (), stmt_loc
);
2290 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2291 ASSERT_EQ (info
->num_items (), 1);
2292 ASSERT_IS_TREE (info
->get_item (0), UNKNOWN_LOCATION
, "1");
2298 /* dump_gimple_stmt_loc. */
2300 temp_dump_context
tmp (with_optinfo
, true,
2301 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2302 dump_gimple_stmt_loc (MSG_NOTE
, loc
, TDF_SLIM
, stmt
, 2);
2304 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: return;\n");
2307 optinfo
*info
= tmp
.get_pending_optinfo ();
2308 ASSERT_TRUE (info
!= NULL
);
2309 ASSERT_EQ (info
->num_items (), 1);
2310 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;\n");
2314 /* dump_gimple_stmt. */
2316 temp_dump_context
tmp (with_optinfo
, true,
2317 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2318 dump_gimple_stmt (MSG_NOTE
, TDF_SLIM
, stmt
, 2);
2320 ASSERT_DUMPED_TEXT_EQ (tmp
, "return;\n");
2323 optinfo
*info
= tmp
.get_pending_optinfo ();
2324 ASSERT_TRUE (info
!= NULL
);
2325 ASSERT_EQ (info
->num_items (), 1);
2326 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;\n");
2330 /* dump_gimple_expr_loc. */
2332 temp_dump_context
tmp (with_optinfo
, true,
2333 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2334 dump_gimple_expr_loc (MSG_NOTE
, loc
, TDF_SLIM
, stmt
, 2);
2336 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: return;");
2339 optinfo
*info
= tmp
.get_pending_optinfo ();
2340 ASSERT_TRUE (info
!= NULL
);
2341 ASSERT_EQ (info
->num_items (), 1);
2342 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;");
2346 /* dump_gimple_expr. */
2348 temp_dump_context
tmp (with_optinfo
, true,
2349 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2350 dump_gimple_expr (MSG_NOTE
, TDF_SLIM
, stmt
, 2);
2352 ASSERT_DUMPED_TEXT_EQ (tmp
, "return;");
2355 optinfo
*info
= tmp
.get_pending_optinfo ();
2356 ASSERT_TRUE (info
!= NULL
);
2357 ASSERT_EQ (info
->num_items (), 1);
2358 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;");
2365 temp_dump_context
tmp (with_optinfo
, true,
2366 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2367 dump_symtab_node (MSG_NOTE
, node
);
2369 ASSERT_DUMPED_TEXT_EQ (tmp
, "test_decl/0");
2372 optinfo
*info
= tmp
.get_pending_optinfo ();
2373 ASSERT_TRUE (info
!= NULL
);
2374 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2375 ASSERT_EQ (info
->num_items (), 1);
2376 ASSERT_IS_SYMTAB_NODE (info
->get_item (0), decl_loc
, "test_decl/0");
2382 temp_dump_context
tmp (with_optinfo
, true,
2383 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2384 dump_dec (MSG_NOTE
, poly_int64 (42));
2386 ASSERT_DUMPED_TEXT_EQ (tmp
, "42");
2389 optinfo
*info
= tmp
.get_pending_optinfo ();
2390 ASSERT_TRUE (info
!= NULL
);
2391 ASSERT_EQ (info
->num_items (), 1);
2392 ASSERT_IS_TEXT (info
->get_item (0), "42");
2396 /* Scopes. Test with all 4 combinations of
2397 filtering by MSG_PRIORITY_USER_FACING
2398 and/or filtering by MSG_PRIORITY_INTERNALS. */
2399 for (int j
= 0; j
< 3; j
++)
2401 dump_flags_t dump_filter
= MSG_ALL_KINDS
;
2403 dump_filter
|= MSG_PRIORITY_USER_FACING
;
2405 dump_filter
|= MSG_PRIORITY_INTERNALS
;
2407 temp_dump_context
tmp (with_optinfo
, true, dump_filter
);
2408 /* Emit various messages, mostly with implicit priority. */
2409 dump_printf_loc (MSG_NOTE
, stmt
, "msg 1\n");
2410 dump_printf_loc (MSG_NOTE
| MSG_PRIORITY_INTERNALS
, stmt
,
2411 "explicitly internal msg\n");
2413 AUTO_DUMP_SCOPE ("outer scope", stmt
);
2414 dump_printf_loc (MSG_NOTE
, stmt
, "msg 2\n");
2416 AUTO_DUMP_SCOPE ("middle scope", stmt
);
2417 dump_printf_loc (MSG_NOTE
, stmt
, "msg 3\n");
2419 AUTO_DUMP_SCOPE ("inner scope", stmt
);
2420 dump_printf_loc (MSG_NOTE
, stmt
, "msg 4\n");
2421 dump_printf_loc (MSG_NOTE
| MSG_PRIORITY_USER_FACING
, stmt
,
2422 "explicitly user-facing msg\n");
2424 dump_printf_loc (MSG_NOTE
, stmt
, "msg 5\n");
2426 dump_printf_loc (MSG_NOTE
, stmt
, "msg 6\n");
2428 dump_printf_loc (MSG_NOTE
, stmt
, "msg 7\n");
2430 switch (dump_filter
& MSG_ALL_PRIORITIES
)
2435 ASSERT_DUMPED_TEXT_EQ (tmp
, "");
2437 case MSG_PRIORITY_USER_FACING
:
2438 ASSERT_DUMPED_TEXT_EQ
2440 "test.txt:5:10: note: msg 1\n"
2441 "test.txt:5:10: note: explicitly user-facing msg\n"
2442 "test.txt:5:10: note: msg 7\n");
2444 case MSG_PRIORITY_INTERNALS
:
2445 ASSERT_DUMPED_TEXT_EQ
2447 "test.txt:5:10: note: explicitly internal msg\n"
2448 "test.txt:5:10: note: === outer scope ===\n"
2449 "test.txt:5:10: note: msg 2\n"
2450 "test.txt:5:10: note: === middle scope ===\n"
2451 "test.txt:5:10: note: msg 3\n"
2452 "test.txt:5:10: note: === inner scope ===\n"
2453 "test.txt:5:10: note: msg 4\n"
2454 "test.txt:5:10: note: msg 5\n"
2455 "test.txt:5:10: note: msg 6\n");
2457 case MSG_ALL_PRIORITIES
:
2458 ASSERT_DUMPED_TEXT_EQ
2460 "test.txt:5:10: note: msg 1\n"
2461 "test.txt:5:10: note: explicitly internal msg\n"
2462 "test.txt:5:10: note: === outer scope ===\n"
2463 "test.txt:5:10: note: msg 2\n"
2464 "test.txt:5:10: note: === middle scope ===\n"
2465 "test.txt:5:10: note: msg 3\n"
2466 "test.txt:5:10: note: === inner scope ===\n"
2467 "test.txt:5:10: note: msg 4\n"
2468 "test.txt:5:10: note: explicitly user-facing msg\n"
2469 "test.txt:5:10: note: msg 5\n"
2470 "test.txt:5:10: note: msg 6\n"
2471 "test.txt:5:10: note: msg 7\n");
2476 optinfo
*info
= tmp
.get_pending_optinfo ();
2477 ASSERT_TRUE (info
!= NULL
);
2478 ASSERT_EQ (info
->num_items (), 1);
2479 ASSERT_IS_TEXT (info
->get_item (0), "msg 7\n");
2484 /* Verify that MSG_* affects optinfo->get_kind (); we tested MSG_NOTE
2487 /* MSG_OPTIMIZED_LOCATIONS. */
2489 temp_dump_context
tmp (true, true, MSG_ALL_KINDS
);
2490 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
, "test");
2491 ASSERT_EQ (tmp
.get_pending_optinfo ()->get_kind (),
2492 OPTINFO_KIND_SUCCESS
);
2495 /* MSG_MISSED_OPTIMIZATION. */
2497 temp_dump_context
tmp (true, true, MSG_ALL_KINDS
);
2498 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
, "test");
2499 ASSERT_EQ (tmp
.get_pending_optinfo ()->get_kind (),
2500 OPTINFO_KIND_FAILURE
);
2504 /* Verify that MSG_* affect AUTO_DUMP_SCOPE and the dump calls. */
2506 temp_dump_context
tmp (false, true,
2507 MSG_OPTIMIZED_LOCATIONS
| MSG_ALL_PRIORITIES
);
2508 dump_printf_loc (MSG_NOTE
, stmt
, "msg 1\n");
2510 AUTO_DUMP_SCOPE ("outer scope", stmt
);
2511 dump_printf_loc (MSG_NOTE
, stmt
, "msg 2\n");
2513 AUTO_DUMP_SCOPE ("middle scope", stmt
);
2514 dump_printf_loc (MSG_NOTE
, stmt
, "msg 3\n");
2516 AUTO_DUMP_SCOPE ("inner scope", stmt
);
2517 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
, "msg 4\n");
2519 dump_printf_loc (MSG_NOTE
, stmt
, "msg 5\n");
2521 dump_printf_loc (MSG_NOTE
, stmt
, "msg 6\n");
2523 dump_printf_loc (MSG_NOTE
, stmt
, "msg 7\n");
2525 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: optimized: msg 4\n");
2529 /* Run all of the selftests within this file. */
2534 test_impl_location ();
2535 for_each_line_table_case (test_capture_of_dump_calls
);
2538 } // namespace selftest
2540 #endif /* CHECKING_P */