1 /* Dump infrastructure for optimizations and intermediate representation.
2 Copyright (C) 2012-2019 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 ()
519 dump_context::set_json_writer (optrecord_json_writer
*writer
)
521 delete m_json_writer
;
522 m_json_writer
= writer
;
525 /* Perform cleanup activity for -fsave-optimization-record.
526 Currently, the file is written out here in one go, before cleaning
530 dump_context::finish_any_json_writer ()
535 m_json_writer
->write ();
536 delete m_json_writer
;
537 m_json_writer
= NULL
;
540 /* Update the "dumps_are_enabled" global; to be called whenever dump_file
541 or alt_dump_file change, or when changing dump_context in selftests. */
544 dump_context::refresh_dumps_are_enabled ()
546 dumps_are_enabled
= (dump_file
|| alt_dump_file
|| optinfo_enabled_p ()
550 /* Determine if a message of kind DUMP_KIND and at the current scope depth
553 Only show messages that match FILTER both on their kind *and*
557 dump_context::apply_dump_filter_p (dump_flags_t dump_kind
,
558 dump_flags_t filter
) const
560 /* Few messages, if any, have an explicit MSG_PRIORITY.
561 If DUMP_KIND does, we'll use it.
562 Otherwise, generate an implicit priority value for the message based
563 on the current scope depth.
564 Messages at the top-level scope are MSG_PRIORITY_USER_FACING,
565 whereas those in nested scopes are MSG_PRIORITY_INTERNALS. */
566 if (!(dump_kind
& MSG_ALL_PRIORITIES
))
568 dump_flags_t implicit_priority
570 ? MSG_PRIORITY_INTERNALS
571 : MSG_PRIORITY_USER_FACING
);
572 dump_kind
|= implicit_priority
;
575 return (dump_kind
& (filter
& MSG_ALL_KINDS
)
576 && dump_kind
& (filter
& MSG_ALL_PRIORITIES
));
579 /* Print LOC to the appropriate dump destinations, given DUMP_KIND.
580 If optinfos are enabled, begin a new optinfo. */
583 dump_context::dump_loc (const dump_metadata_t
&metadata
,
584 const dump_user_location_t
&loc
)
588 dump_loc_immediate (metadata
.get_dump_flags (), loc
);
590 if (optinfo_enabled_p ())
591 begin_next_optinfo (metadata
, loc
);
594 /* As dump_loc above, but without starting a new optinfo. */
597 dump_context::dump_loc_immediate (dump_flags_t dump_kind
,
598 const dump_user_location_t
&loc
)
600 location_t srcloc
= loc
.get_location_t ();
602 if (dump_file
&& apply_dump_filter_p (dump_kind
, pflags
))
603 ::dump_loc (dump_kind
, dump_file
, srcloc
);
605 if (alt_dump_file
&& apply_dump_filter_p (dump_kind
, alt_flags
))
606 ::dump_loc (dump_kind
, alt_dump_file
, srcloc
);
608 /* Support for temp_dump_context in selftests. */
609 if (m_test_pp
&& apply_dump_filter_p (dump_kind
, m_test_pp_flags
))
610 ::dump_loc (dump_kind
, m_test_pp
, srcloc
);
613 /* Make an item for the given dump call, equivalent to print_gimple_stmt. */
615 static optinfo_item
*
616 make_item_for_dump_gimple_stmt (gimple
*stmt
, int spc
, dump_flags_t dump_flags
)
619 pp_needs_newline (&pp
) = true;
620 pp_gimple_stmt_1 (&pp
, stmt
, spc
, dump_flags
);
624 = new optinfo_item (OPTINFO_ITEM_KIND_GIMPLE
, gimple_location (stmt
),
625 xstrdup (pp_formatted_text (&pp
)));
629 /* Dump gimple statement GS with SPC indentation spaces and
630 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled. */
633 dump_context::dump_gimple_stmt (const dump_metadata_t
&metadata
,
634 dump_flags_t extra_dump_flags
,
638 = make_item_for_dump_gimple_stmt (gs
, spc
, dump_flags
| extra_dump_flags
);
639 emit_item (item
, metadata
.get_dump_flags ());
641 if (optinfo_enabled_p ())
643 optinfo
&info
= ensure_pending_optinfo (metadata
);
644 info
.add_item (item
);
650 /* Similar to dump_gimple_stmt, except additionally print source location. */
653 dump_context::dump_gimple_stmt_loc (const dump_metadata_t
&metadata
,
654 const dump_user_location_t
&loc
,
655 dump_flags_t extra_dump_flags
,
658 dump_loc (metadata
, loc
);
659 dump_gimple_stmt (metadata
, extra_dump_flags
, gs
, spc
);
662 /* Make an item for the given dump call, equivalent to print_gimple_expr. */
664 static optinfo_item
*
665 make_item_for_dump_gimple_expr (gimple
*stmt
, int spc
, dump_flags_t dump_flags
)
667 dump_flags
|= TDF_RHS_ONLY
;
669 pp_needs_newline (&pp
) = true;
670 pp_gimple_stmt_1 (&pp
, stmt
, spc
, dump_flags
);
673 = new optinfo_item (OPTINFO_ITEM_KIND_GIMPLE
, gimple_location (stmt
),
674 xstrdup (pp_formatted_text (&pp
)));
678 /* Dump gimple statement GS with SPC indentation spaces and
679 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled.
680 Do not terminate with a newline or semicolon. */
683 dump_context::dump_gimple_expr (const dump_metadata_t
&metadata
,
684 dump_flags_t extra_dump_flags
,
688 = make_item_for_dump_gimple_expr (gs
, spc
, dump_flags
| extra_dump_flags
);
689 emit_item (item
, metadata
.get_dump_flags ());
691 if (optinfo_enabled_p ())
693 optinfo
&info
= ensure_pending_optinfo (metadata
);
694 info
.add_item (item
);
700 /* Similar to dump_gimple_expr, except additionally print source location. */
703 dump_context::dump_gimple_expr_loc (const dump_metadata_t
&metadata
,
704 const dump_user_location_t
&loc
,
705 dump_flags_t extra_dump_flags
,
709 dump_loc (metadata
, loc
);
710 dump_gimple_expr (metadata
, extra_dump_flags
, gs
, spc
);
713 /* Make an item for the given dump call, equivalent to print_generic_expr. */
715 static optinfo_item
*
716 make_item_for_dump_generic_expr (tree node
, dump_flags_t dump_flags
)
719 pp_needs_newline (&pp
) = true;
720 pp_translate_identifiers (&pp
) = false;
721 dump_generic_node (&pp
, node
, 0, dump_flags
, false);
723 location_t loc
= UNKNOWN_LOCATION
;
724 if (EXPR_HAS_LOCATION (node
))
725 loc
= EXPR_LOCATION (node
);
728 = new optinfo_item (OPTINFO_ITEM_KIND_TREE
, loc
,
729 xstrdup (pp_formatted_text (&pp
)));
733 /* Dump expression tree T using EXTRA_DUMP_FLAGS on dump streams if
734 DUMP_KIND is enabled. */
737 dump_context::dump_generic_expr (const dump_metadata_t
&metadata
,
738 dump_flags_t extra_dump_flags
,
742 = make_item_for_dump_generic_expr (t
, dump_flags
| extra_dump_flags
);
743 emit_item (item
, metadata
.get_dump_flags ());
745 if (optinfo_enabled_p ())
747 optinfo
&info
= ensure_pending_optinfo (metadata
);
748 info
.add_item (item
);
755 /* Similar to dump_generic_expr, except additionally print the source
759 dump_context::dump_generic_expr_loc (const dump_metadata_t
&metadata
,
760 const dump_user_location_t
&loc
,
761 dump_flags_t extra_dump_flags
,
764 dump_loc (metadata
, loc
);
765 dump_generic_expr (metadata
, extra_dump_flags
, t
);
768 /* Make an item for the given dump call. */
770 static optinfo_item
*
771 make_item_for_dump_symtab_node (symtab_node
*node
)
773 location_t loc
= DECL_SOURCE_LOCATION (node
->decl
);
775 = new optinfo_item (OPTINFO_ITEM_KIND_SYMTAB_NODE
, loc
,
776 xstrdup (node
->dump_name ()));
780 /* dump_pretty_printer's ctor. */
782 dump_pretty_printer::dump_pretty_printer (dump_context
*context
,
783 dump_flags_t dump_kind
)
784 : pretty_printer (), m_context (context
), m_dump_kind (dump_kind
),
787 pp_format_decoder (this) = format_decoder_cb
;
790 /* Phase 3 of formatting; compare with pp_output_formatted_text.
792 Emit optinfo_item instances for the various formatted chunks from phases
793 1 and 2 (i.e. pp_format).
795 Some chunks may already have had their items built (during decode_format).
796 These chunks have been stashed into m_stashed_items; we emit them here.
798 For all other purely textual chunks, they are printed into
799 buffer->formatted_obstack, and then emitted as a textual optinfo_item.
800 This consolidates multiple adjacent text chunks into a single text
804 dump_pretty_printer::emit_items (optinfo
*dest
)
806 output_buffer
*buffer
= pp_buffer (this);
807 struct chunk_info
*chunk_array
= buffer
->cur_chunk_array
;
808 const char **args
= chunk_array
->args
;
810 gcc_assert (buffer
->obstack
== &buffer
->formatted_obstack
);
811 gcc_assert (buffer
->line_length
== 0);
813 unsigned stashed_item_idx
= 0;
814 for (unsigned chunk
= 0; args
[chunk
]; chunk
++)
816 if (stashed_item_idx
< m_stashed_items
.length ()
817 && args
[chunk
] == *m_stashed_items
[stashed_item_idx
].buffer_ptr
)
819 emit_any_pending_textual_chunks (dest
);
820 /* This chunk has a stashed item: use it. */
821 emit_item (m_stashed_items
[stashed_item_idx
++].item
, dest
);
824 /* This chunk is purely textual. Print it (to
825 buffer->formatted_obstack), so that we can consolidate adjacent
826 chunks into one textual optinfo_item. */
827 pp_string (this, args
[chunk
]);
830 emit_any_pending_textual_chunks (dest
);
832 /* Ensure that we consumed all of stashed_items. */
833 gcc_assert (stashed_item_idx
== m_stashed_items
.length ());
835 /* Deallocate the chunk structure and everything after it (i.e. the
836 associated series of formatted strings). */
837 buffer
->cur_chunk_array
= chunk_array
->prev
;
838 obstack_free (&buffer
->chunk_obstack
, chunk_array
);
841 /* Subroutine of dump_pretty_printer::emit_items
842 for consolidating multiple adjacent pure-text chunks into single
843 optinfo_items (in phase 3). */
846 dump_pretty_printer::emit_any_pending_textual_chunks (optinfo
*dest
)
848 gcc_assert (buffer
->obstack
== &buffer
->formatted_obstack
);
850 /* Don't emit an item if the pending text is empty. */
851 if (output_buffer_last_position_in_text (buffer
) == NULL
)
854 char *formatted_text
= xstrdup (pp_formatted_text (this));
856 = new optinfo_item (OPTINFO_ITEM_KIND_TEXT
, UNKNOWN_LOCATION
,
858 emit_item (item
, dest
);
860 /* Clear the pending text by unwinding formatted_text back to the start
861 of the buffer (without deallocating). */
862 obstack_free (&buffer
->formatted_obstack
,
863 buffer
->formatted_obstack
.object_base
);
866 /* Emit ITEM and take ownership of it. If DEST is non-NULL, add ITEM
867 to DEST; otherwise delete ITEM. */
870 dump_pretty_printer::emit_item (optinfo_item
*item
, optinfo
*dest
)
872 m_context
->emit_item (item
, m_dump_kind
);
874 dest
->add_item (item
);
879 /* Record that ITEM (generated in phase 2 of formatting) is to be used for
880 the chunk at BUFFER_PTR in phase 3 (by emit_items). */
883 dump_pretty_printer::stash_item (const char **buffer_ptr
, optinfo_item
*item
)
885 gcc_assert (buffer_ptr
);
888 m_stashed_items
.safe_push (stashed_item (buffer_ptr
, item
));
891 /* pp_format_decoder callback for dump_pretty_printer, and thus for
892 dump_printf and dump_printf_loc.
894 A wrapper around decode_format, for type-safety. */
897 dump_pretty_printer::format_decoder_cb (pretty_printer
*pp
, text_info
*text
,
898 const char *spec
, int /*precision*/,
899 bool /*wide*/, bool /*set_locus*/,
900 bool /*verbose*/, bool */
*quoted*/
,
901 const char **buffer_ptr
)
903 dump_pretty_printer
*opp
= static_cast <dump_pretty_printer
*> (pp
);
904 return opp
->decode_format (text
, spec
, buffer_ptr
);
907 /* Format decoder for dump_pretty_printer, and thus for dump_printf and
910 Supported format codes (in addition to the standard pretty_printer ones)
914 Equivalent to: dump_symtab_node (MSG_*, node)
916 Equivalent to: dump_gimple_expr (MSG_*, TDF_SLIM, stmt, 0)
918 Equivalent to: dump_gimple_stmt (MSG_*, TDF_SLIM, stmt, 0)
920 Equivalent to: dump_generic_expr (MSG_*, arg, TDF_SLIM).
922 TODO: add a format code that can handle (symtab_node*) *and* both
923 subclasses (presumably means teaching -Wformat about non-virtual
926 These format codes build optinfo_item instances, thus capturing metadata
927 about the arguments being dumped, as well as the textual output. */
930 dump_pretty_printer::decode_format (text_info
*text
, const char *spec
,
931 const char **buffer_ptr
)
933 /* Various format codes that imply making an optinfo_item and stashed it
934 for later use (to capture metadata, rather than plain text). */
939 cgraph_node
*node
= va_arg (*text
->args_ptr
, cgraph_node
*);
941 /* Make an item for the node, and stash it. */
942 optinfo_item
*item
= make_item_for_dump_symtab_node (node
);
943 stash_item (buffer_ptr
, item
);
949 gimple
*stmt
= va_arg (*text
->args_ptr
, gimple
*);
951 /* Make an item for the stmt, and stash it. */
952 optinfo_item
*item
= make_item_for_dump_gimple_expr (stmt
, 0, TDF_SLIM
);
953 stash_item (buffer_ptr
, item
);
959 gimple
*stmt
= va_arg (*text
->args_ptr
, gimple
*);
961 /* Make an item for the stmt, and stash it. */
962 optinfo_item
*item
= make_item_for_dump_gimple_stmt (stmt
, 0, TDF_SLIM
);
963 stash_item (buffer_ptr
, item
);
969 tree t
= va_arg (*text
->args_ptr
, tree
);
971 /* Make an item for the tree, and stash it. */
972 optinfo_item
*item
= make_item_for_dump_generic_expr (t
, TDF_SLIM
);
973 stash_item (buffer_ptr
, item
);
982 /* Output a formatted message using FORMAT on appropriate dump streams. */
985 dump_context::dump_printf_va (const dump_metadata_t
&metadata
, const char *format
,
988 dump_pretty_printer
pp (this, metadata
.get_dump_flags ());
993 text
.format_spec
= format
;
995 /* Phases 1 and 2, using pp_format. */
996 pp_format (&pp
, &text
);
999 if (optinfo_enabled_p ())
1001 optinfo
&info
= ensure_pending_optinfo (metadata
);
1002 pp
.emit_items (&info
);
1005 pp
.emit_items (NULL
);
1008 /* Similar to dump_printf, except source location is also printed, and
1009 dump location captured. */
1012 dump_context::dump_printf_loc_va (const dump_metadata_t
&metadata
,
1013 const dump_user_location_t
&loc
,
1014 const char *format
, va_list *ap
)
1016 dump_loc (metadata
, loc
);
1017 dump_printf_va (metadata
, format
, ap
);
1020 /* Make an item for the given dump call, equivalent to print_dec. */
1022 template<unsigned int N
, typename C
>
1023 static optinfo_item
*
1024 make_item_for_dump_dec (const poly_int
<N
, C
> &value
)
1026 STATIC_ASSERT (poly_coeff_traits
<C
>::signedness
>= 0);
1027 signop sgn
= poly_coeff_traits
<C
>::signedness
? SIGNED
: UNSIGNED
;
1031 if (value
.is_constant ())
1032 pp_wide_int (&pp
, value
.coeffs
[0], sgn
);
1035 pp_character (&pp
, '[');
1036 for (unsigned int i
= 0; i
< N
; ++i
)
1038 pp_wide_int (&pp
, value
.coeffs
[i
], sgn
);
1039 pp_character (&pp
, i
== N
- 1 ? ']' : ',');
1044 = new optinfo_item (OPTINFO_ITEM_KIND_TEXT
, UNKNOWN_LOCATION
,
1045 xstrdup (pp_formatted_text (&pp
)));
1049 /* Output VALUE in decimal to appropriate dump streams. */
1051 template<unsigned int N
, typename C
>
1053 dump_context::dump_dec (const dump_metadata_t
&metadata
, const poly_int
<N
, C
> &value
)
1055 optinfo_item
*item
= make_item_for_dump_dec (value
);
1056 emit_item (item
, metadata
.get_dump_flags ());
1058 if (optinfo_enabled_p ())
1060 optinfo
&info
= ensure_pending_optinfo (metadata
);
1061 info
.add_item (item
);
1067 /* Output the name of NODE on appropriate dump streams. */
1070 dump_context::dump_symtab_node (const dump_metadata_t
&metadata
, symtab_node
*node
)
1072 optinfo_item
*item
= make_item_for_dump_symtab_node (node
);
1073 emit_item (item
, metadata
.get_dump_flags ());
1075 if (optinfo_enabled_p ())
1077 optinfo
&info
= ensure_pending_optinfo (metadata
);
1078 info
.add_item (item
);
1084 /* Get the current dump scope-nesting depth.
1085 For use by -fopt-info (for showing nesting via indentation). */
1088 dump_context::get_scope_depth () const
1090 return m_scope_depth
;
1093 /* Push a nested dump scope.
1094 Increment the scope depth.
1095 Print "=== NAME ===\n" to the dumpfile, if any, and to the -fopt-info
1096 destination, if any.
1097 Emit a "scope" optinfo if optinfos are enabled. */
1100 dump_context::begin_scope (const char *name
,
1101 const dump_user_location_t
&user_location
,
1102 const dump_impl_location_t
&impl_location
)
1106 location_t src_loc
= user_location
.get_location_t ();
1108 if (dump_file
&& apply_dump_filter_p (MSG_NOTE
, pflags
))
1109 ::dump_loc (MSG_NOTE
, dump_file
, src_loc
);
1111 if (alt_dump_file
&& apply_dump_filter_p (MSG_NOTE
, alt_flags
))
1112 ::dump_loc (MSG_NOTE
, alt_dump_file
, src_loc
);
1114 /* Support for temp_dump_context in selftests. */
1115 if (m_test_pp
&& apply_dump_filter_p (MSG_NOTE
, m_test_pp_flags
))
1116 ::dump_loc (MSG_NOTE
, m_test_pp
, src_loc
);
1119 pp_printf (&pp
, "=== %s ===\n", name
);
1121 = new optinfo_item (OPTINFO_ITEM_KIND_TEXT
, UNKNOWN_LOCATION
,
1122 xstrdup (pp_formatted_text (&pp
)));
1123 emit_item (item
, MSG_NOTE
);
1125 if (optinfo_enabled_p ())
1128 = begin_next_optinfo (dump_metadata_t (MSG_NOTE
, impl_location
),
1130 info
.m_kind
= OPTINFO_KIND_SCOPE
;
1131 info
.add_item (item
);
1138 /* Pop a nested dump scope. */
1141 dump_context::end_scope ()
1147 m_json_writer
->pop_scope ();
1150 /* Should optinfo instances be created?
1151 All creation of optinfos should be guarded by this predicate.
1152 Return true if any optinfo destinations are active. */
1155 dump_context::optinfo_enabled_p () const
1157 return (optimization_records_enabled_p ());
1160 /* Return the optinfo currently being accumulated, creating one if
1164 dump_context::ensure_pending_optinfo (const dump_metadata_t
&metadata
)
1167 return begin_next_optinfo (metadata
, dump_user_location_t ());
1171 /* Start a new optinfo and return it, ending any optinfo that was already
1175 dump_context::begin_next_optinfo (const dump_metadata_t
&metadata
,
1176 const dump_user_location_t
&user_loc
)
1179 gcc_assert (m_pending
== NULL
);
1180 dump_location_t
loc (user_loc
, metadata
.get_impl_location ());
1181 m_pending
= new optinfo (loc
, OPTINFO_KIND_NOTE
, current_pass
);
1182 m_pending
->handle_dump_file_kind (metadata
.get_dump_flags ());
1186 /* End any optinfo that has been accumulated within this context; emitting
1187 it to any destinations as appropriate, such as optimization records. */
1190 dump_context::end_any_optinfo ()
1193 emit_optinfo (m_pending
);
1198 /* Emit the optinfo to all of the "non-immediate" destinations
1199 (emission to "immediate" destinations is done by
1200 dump_context::emit_item). */
1203 dump_context::emit_optinfo (const optinfo
*info
)
1205 /* -fsave-optimization-record. */
1207 m_json_writer
->add_record (info
);
1210 /* Emit ITEM to all item destinations (those that don't require
1211 consolidation into optinfo instances). */
1214 dump_context::emit_item (optinfo_item
*item
, dump_flags_t dump_kind
)
1216 if (dump_file
&& apply_dump_filter_p (dump_kind
, pflags
))
1217 fprintf (dump_file
, "%s", item
->get_text ());
1219 if (alt_dump_file
&& apply_dump_filter_p (dump_kind
, alt_flags
))
1220 fprintf (alt_dump_file
, "%s", item
->get_text ());
1222 /* Support for temp_dump_context in selftests. */
1223 if (m_test_pp
&& apply_dump_filter_p (dump_kind
, m_test_pp_flags
))
1224 pp_string (m_test_pp
, item
->get_text ());
1227 /* The current singleton dump_context, and its default. */
1229 dump_context
*dump_context::s_current
= &dump_context::s_default
;
1230 dump_context
dump_context::s_default
;
1232 /* Implementation of dump_* API calls, calling into dump_context
1233 member functions. */
1235 /* Calls to the dump_* functions do non-trivial work, so they ought
1237 if (dump_enabled_p ())
1238 Assert that they are guarded, and, if assertions are disabled,
1239 bail out if the calls weren't properly guarded. */
1241 #define VERIFY_DUMP_ENABLED_P \
1243 gcc_assert (dump_enabled_p ()); \
1244 if (!dump_enabled_p ()) \
1248 /* Dump gimple statement GS with SPC indentation spaces and
1249 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled. */
1252 dump_gimple_stmt (const dump_metadata_t
&metadata
, dump_flags_t extra_dump_flags
,
1253 gimple
*gs
, int spc
)
1255 VERIFY_DUMP_ENABLED_P
;
1256 dump_context::get ().dump_gimple_stmt (metadata
, extra_dump_flags
, gs
, spc
);
1259 /* Similar to dump_gimple_stmt, except additionally print source location. */
1262 dump_gimple_stmt_loc (const dump_metadata_t
&metadata
,
1263 const dump_user_location_t
&loc
,
1264 dump_flags_t extra_dump_flags
, gimple
*gs
, int spc
)
1266 VERIFY_DUMP_ENABLED_P
;
1267 dump_context::get ().dump_gimple_stmt_loc (metadata
, loc
, extra_dump_flags
,
1271 /* Dump gimple statement GS with SPC indentation spaces and
1272 EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled.
1273 Do not terminate with a newline or semicolon. */
1276 dump_gimple_expr (const dump_metadata_t
&metadata
,
1277 dump_flags_t extra_dump_flags
,
1278 gimple
*gs
, int spc
)
1280 VERIFY_DUMP_ENABLED_P
;
1281 dump_context::get ().dump_gimple_expr (metadata
, extra_dump_flags
, gs
, spc
);
1284 /* Similar to dump_gimple_expr, except additionally print source location. */
1287 dump_gimple_expr_loc (const dump_metadata_t
&metadata
,
1288 const dump_user_location_t
&loc
,
1289 dump_flags_t extra_dump_flags
, gimple
*gs
, int spc
)
1291 VERIFY_DUMP_ENABLED_P
;
1292 dump_context::get ().dump_gimple_expr_loc (metadata
, loc
, extra_dump_flags
,
1296 /* Dump expression tree T using EXTRA_DUMP_FLAGS on dump streams if
1297 DUMP_KIND is enabled. */
1300 dump_generic_expr (const dump_metadata_t
&metadata
, dump_flags_t extra_dump_flags
,
1303 VERIFY_DUMP_ENABLED_P
;
1304 dump_context::get ().dump_generic_expr (metadata
, extra_dump_flags
, t
);
1307 /* Similar to dump_generic_expr, except additionally print the source
1311 dump_generic_expr_loc (const dump_metadata_t
&metadata
,
1312 const dump_user_location_t
&loc
,
1313 dump_flags_t extra_dump_flags
, tree t
)
1315 VERIFY_DUMP_ENABLED_P
;
1316 dump_context::get ().dump_generic_expr_loc (metadata
, loc
, extra_dump_flags
,
1320 /* Output a formatted message using FORMAT on appropriate dump streams. */
1323 dump_printf (const dump_metadata_t
&metadata
, const char *format
, ...)
1325 VERIFY_DUMP_ENABLED_P
;
1327 va_start (ap
, format
);
1328 dump_context::get ().dump_printf_va (metadata
, format
, &ap
);
1332 /* Similar to dump_printf, except source location is also printed, and
1333 dump location captured. */
1336 dump_printf_loc (const dump_metadata_t
&metadata
,
1337 const dump_user_location_t
&loc
,
1338 const char *format
, ...)
1340 VERIFY_DUMP_ENABLED_P
;
1342 va_start (ap
, format
);
1343 dump_context::get ().dump_printf_loc_va (metadata
, loc
, format
, &ap
);
1347 /* Output VALUE in decimal to appropriate dump streams. */
1349 template<unsigned int N
, typename C
>
1351 dump_dec (const dump_metadata_t
&metadata
, const poly_int
<N
, C
> &value
)
1353 VERIFY_DUMP_ENABLED_P
;
1354 dump_context::get ().dump_dec (metadata
, value
);
1357 template void dump_dec (const dump_metadata_t
&metadata
, const poly_uint16
&);
1358 template void dump_dec (const dump_metadata_t
&metadata
, const poly_int64
&);
1359 template void dump_dec (const dump_metadata_t
&metadata
, const poly_uint64
&);
1360 template void dump_dec (const dump_metadata_t
&metadata
, const poly_offset_int
&);
1361 template void dump_dec (const dump_metadata_t
&metadata
, const poly_widest_int
&);
1364 dump_dec (dump_flags_t dump_kind
, const poly_wide_int
&value
, signop sgn
)
1366 VERIFY_DUMP_ENABLED_P
;
1368 && dump_context::get ().apply_dump_filter_p (dump_kind
, pflags
))
1369 print_dec (value
, dump_file
, sgn
);
1372 && dump_context::get ().apply_dump_filter_p (dump_kind
, alt_flags
))
1373 print_dec (value
, alt_dump_file
, sgn
);
1376 /* Output VALUE in hexadecimal to appropriate dump streams. */
1379 dump_hex (dump_flags_t dump_kind
, const poly_wide_int
&value
)
1381 VERIFY_DUMP_ENABLED_P
;
1383 && dump_context::get ().apply_dump_filter_p (dump_kind
, pflags
))
1384 print_hex (value
, dump_file
);
1387 && dump_context::get ().apply_dump_filter_p (dump_kind
, alt_flags
))
1388 print_hex (value
, alt_dump_file
);
1391 /* Emit and delete the currently pending optinfo, if there is one,
1392 without the caller needing to know about class dump_context. */
1395 dumpfile_ensure_any_optinfo_are_flushed ()
1397 dump_context::get().end_any_optinfo ();
1400 /* Output the name of NODE on appropriate dump streams. */
1403 dump_symtab_node (const dump_metadata_t
&metadata
, symtab_node
*node
)
1405 VERIFY_DUMP_ENABLED_P
;
1406 dump_context::get ().dump_symtab_node (metadata
, node
);
1409 /* Get the current dump scope-nesting depth.
1410 For use by -fopt-info (for showing nesting via indentation). */
1413 get_dump_scope_depth ()
1415 return dump_context::get ().get_scope_depth ();
1418 /* Push a nested dump scope.
1419 Print "=== NAME ===\n" to the dumpfile, if any, and to the -fopt-info
1420 destination, if any.
1421 Emit a "scope" opinfo if optinfos are enabled.
1422 Increment the scope depth. */
1425 dump_begin_scope (const char *name
,
1426 const dump_user_location_t
&user_location
,
1427 const dump_impl_location_t
&impl_location
)
1429 dump_context::get ().begin_scope (name
, user_location
, impl_location
);
1432 /* Pop a nested dump scope. */
1437 dump_context::get ().end_scope ();
1440 /* Start a dump for PHASE. Store user-supplied dump flags in
1441 *FLAG_PTR. Return the number of streams opened. Set globals
1442 DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and
1443 set dump_flags appropriately for both pass dump stream and
1444 -fopt-info stream. */
1448 dump_start (int phase
, dump_flags_t
*flag_ptr
)
1452 struct dump_file_info
*dfi
;
1454 if (phase
== TDI_none
|| !dump_phase_enabled_p (phase
))
1457 dfi
= get_dump_file_info (phase
);
1458 name
= get_dump_file_name (phase
);
1461 stream
= dump_open (name
, dfi
->pstate
< 0);
1468 dfi
->pstream
= stream
;
1469 set_dump_file (dfi
->pstream
);
1470 /* Initialize current dump flags. */
1471 pflags
= dfi
->pflags
;
1474 stream
= dump_open_alternate_stream (dfi
);
1477 dfi
->alt_stream
= stream
;
1479 set_alt_dump_file (dfi
->alt_stream
);
1480 /* Initialize current -fopt-info flags. */
1481 alt_flags
= dfi
->alt_flags
;
1485 *flag_ptr
= dfi
->pflags
;
1490 /* Finish a tree dump for PHASE and close associated dump streams. Also
1491 reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS. */
1495 dump_finish (int phase
)
1497 struct dump_file_info
*dfi
;
1501 dfi
= get_dump_file_info (phase
);
1502 if (dfi
->pstream
&& dfi
->pstream
!= stdout
&& dfi
->pstream
!= stderr
)
1503 fclose (dfi
->pstream
);
1505 if (dfi
->alt_stream
&& dfi
->alt_stream
!= stdout
&& dfi
->alt_stream
!= stderr
)
1506 fclose (dfi
->alt_stream
);
1508 dfi
->alt_stream
= NULL
;
1509 dfi
->pstream
= NULL
;
1510 set_dump_file (NULL
);
1511 set_alt_dump_file (NULL
);
1512 dump_flags
= TDF_NONE
;
1513 alt_flags
= TDF_NONE
;
1517 /* Begin a tree dump for PHASE. Stores any user supplied flag in
1518 *FLAG_PTR and returns a stream to write to. If the dump is not
1519 enabled, returns NULL.
1520 PART can be used for dump files which should be split to multiple
1521 parts. PART == -1 indicates dump file with no parts.
1522 If PART is -1, multiple calls will reopen and append to the dump file. */
1525 dump_begin (int phase
, dump_flags_t
*flag_ptr
, int part
)
1527 return g
->get_dumps ()->dump_begin (phase
, flag_ptr
, part
);
1532 dump_begin (int phase
, dump_flags_t
*flag_ptr
, int part
)
1535 struct dump_file_info
*dfi
;
1538 if (phase
== TDI_none
|| !dump_phase_enabled_p (phase
))
1541 name
= get_dump_file_name (phase
, part
);
1544 dfi
= get_dump_file_info (phase
);
1546 /* We do not support re-opening of dump files with parts. This would require
1547 tracking pstate per part of the dump file. */
1548 stream
= dump_open (name
, part
!= -1 || dfi
->pstate
< 0);
1554 *flag_ptr
= dfi
->pflags
;
1556 /* Initialize current flags */
1557 pflags
= dfi
->pflags
;
1561 /* Returns nonzero if dump PHASE is enabled for at least one stream.
1562 If PHASE is TDI_tree_all, return nonzero if any dump is enabled for
1567 dump_phase_enabled_p (int phase
) const
1569 if (phase
== TDI_tree_all
)
1572 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1573 if (dump_files
[i
].pstate
|| dump_files
[i
].alt_state
)
1575 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1576 if (m_extra_dump_files
[i
].pstate
|| m_extra_dump_files
[i
].alt_state
)
1582 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
1583 return dfi
->pstate
|| dfi
->alt_state
;
1587 /* Returns nonzero if tree dump PHASE has been initialized. */
1591 dump_initialized_p (int phase
) const
1593 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
1594 return dfi
->pstate
> 0 || dfi
->alt_state
> 0;
1597 /* Returns the switch name of PHASE. */
1600 dump_flag_name (int phase
)
1602 return g
->get_dumps ()->dump_flag_name (phase
);
1607 dump_flag_name (int phase
) const
1609 struct dump_file_info
*dfi
= get_dump_file_info (phase
);
1613 /* Handle -fdump-* and -fopt-info for a pass added after
1614 command-line options are parsed (those from plugins and
1615 those from backends).
1617 Because the registration of plugin/backend passes happens after the
1618 command-line options are parsed, the options that specify single
1619 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
1620 passes. Therefore we currently can only enable dumping of
1621 new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
1622 are specified. This is done here.
1624 Similarly, the saved -fopt-info options are wired up to the new pass. */
1627 gcc::dump_manager::register_pass (opt_pass
*pass
)
1631 register_one_dump_file (pass
);
1633 dump_file_info
*pass_dfi
= get_dump_file_info (pass
->static_pass_number
);
1634 gcc_assert (pass_dfi
);
1636 enum tree_dump_index tdi
;
1637 if (pass
->type
== SIMPLE_IPA_PASS
1638 || pass
->type
== IPA_PASS
)
1640 else if (pass
->type
== GIMPLE_PASS
)
1644 const dump_file_info
*tdi_dfi
= get_dump_file_info (tdi
);
1645 gcc_assert (tdi_dfi
);
1647 /* Check if dump-all flag is specified. */
1648 if (tdi_dfi
->pstate
)
1650 pass_dfi
->pstate
= tdi_dfi
->pstate
;
1651 pass_dfi
->pflags
= tdi_dfi
->pflags
;
1654 update_dfi_for_opt_info (pass_dfi
);
1657 /* Finish a tree dump for PHASE. STREAM is the stream created by
1661 dump_end (int phase ATTRIBUTE_UNUSED
, FILE *stream
)
1663 if (stream
!= stderr
&& stream
!= stdout
)
1667 /* Enable all tree dumps with FLAGS on FILENAME. Return number of
1668 enabled tree dumps. */
1672 dump_enable_all (dump_kind dkind
, dump_flags_t flags
, const char *filename
)
1677 for (i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1679 if (dump_files
[i
].dkind
== dkind
)
1681 const char *old_filename
= dump_files
[i
].pfilename
;
1682 dump_files
[i
].pstate
= -1;
1683 dump_files
[i
].pflags
|= flags
;
1685 /* Override the existing filename. */
1688 dump_files
[i
].pfilename
= xstrdup (filename
);
1689 /* Since it is a command-line provided file, which is
1690 common to all the phases, use it in append mode. */
1691 dump_files
[i
].pstate
= 1;
1693 if (old_filename
&& filename
!= old_filename
)
1694 free (CONST_CAST (char *, old_filename
));
1698 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1700 if (m_extra_dump_files
[i
].dkind
== dkind
)
1702 const char *old_filename
= m_extra_dump_files
[i
].pfilename
;
1703 m_extra_dump_files
[i
].pstate
= -1;
1704 m_extra_dump_files
[i
].pflags
|= flags
;
1706 /* Override the existing filename. */
1709 m_extra_dump_files
[i
].pfilename
= xstrdup (filename
);
1710 /* Since it is a command-line provided file, which is
1711 common to all the phases, use it in append mode. */
1712 m_extra_dump_files
[i
].pstate
= 1;
1714 if (old_filename
&& filename
!= old_filename
)
1715 free (CONST_CAST (char *, old_filename
));
1722 /* Enable -fopt-info dumps on all dump files matching OPTGROUP_FLAGS.
1723 Enable dumps with FLAGS on FILENAME. Return the number of enabled
1728 opt_info_enable_passes (optgroup_flags_t optgroup_flags
, dump_flags_t flags
,
1729 const char *filename
)
1733 m_optgroup_flags
= optgroup_flags
;
1734 m_optinfo_flags
= flags
;
1735 m_optinfo_filename
= xstrdup (filename
);
1737 for (size_t i
= TDI_none
+ 1; i
< (size_t) TDI_end
; i
++)
1738 if (update_dfi_for_opt_info (&dump_files
[i
]))
1741 for (size_t i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1742 if (update_dfi_for_opt_info (&m_extra_dump_files
[i
]))
1748 /* Use the saved -fopt-info options to update DFI.
1749 Return true if the dump is enabled. */
1752 gcc::dump_manager::update_dfi_for_opt_info (dump_file_info
*dfi
) const
1756 if (!(dfi
->optgroup_flags
& m_optgroup_flags
))
1759 const char *old_filename
= dfi
->alt_filename
;
1760 /* Since this file is shared among different passes, it
1761 should be opened in append mode. */
1763 dfi
->alt_flags
|= m_optinfo_flags
;
1764 /* Override the existing filename. */
1765 if (m_optinfo_filename
)
1766 dfi
->alt_filename
= xstrdup (m_optinfo_filename
);
1767 if (old_filename
&& m_optinfo_filename
!= old_filename
)
1768 free (CONST_CAST (char *, old_filename
));
1773 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
1774 relevant details in the dump_files array. */
1778 dump_switch_p_1 (const char *arg
, struct dump_file_info
*dfi
, bool doglob
)
1780 const char *option_value
;
1784 if (doglob
&& !dfi
->glob
)
1787 option_value
= skip_leading_substring (arg
, doglob
? dfi
->glob
: dfi
->swtch
);
1791 if (*option_value
&& *option_value
!= '-' && *option_value
!= '=')
1796 /* Retain "user-facing" and "internals" messages, but filter out
1797 those from an opt_problem being re-emitted at the top level
1798 (MSG_PRIORITY_REEMITTED), so as to avoid duplicate messages
1799 messing up scan-tree-dump-times" in DejaGnu tests. */
1800 flags
= MSG_PRIORITY_USER_FACING
| MSG_PRIORITY_INTERNALS
;
1804 const struct kv_pair
<dump_flags_t
> *option_ptr
;
1805 const char *end_ptr
;
1811 end_ptr
= strchr (ptr
, '-');
1812 eq_ptr
= strchr (ptr
, '=');
1814 if (eq_ptr
&& !end_ptr
)
1818 end_ptr
= ptr
+ strlen (ptr
);
1819 length
= end_ptr
- ptr
;
1821 for (option_ptr
= dump_options
; option_ptr
->name
; option_ptr
++)
1822 if (strlen (option_ptr
->name
) == length
1823 && !memcmp (option_ptr
->name
, ptr
, length
))
1825 flags
|= option_ptr
->value
;
1831 /* Interpret rest of the argument as a dump filename. This
1832 filename overrides other command line filenames. */
1834 free (CONST_CAST (char *, dfi
->pfilename
));
1835 dfi
->pfilename
= xstrdup (ptr
+ 1);
1839 warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
1840 length
, ptr
, dfi
->swtch
);
1846 dfi
->pflags
|= flags
;
1848 /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
1850 if (dfi
->suffix
== NULL
)
1851 dump_enable_all (dfi
->dkind
, dfi
->pflags
, dfi
->pfilename
);
1858 dump_switch_p (const char *arg
)
1863 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1864 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], false);
1866 /* Don't glob if we got a hit already */
1868 for (i
= TDI_none
+ 1; i
!= TDI_end
; i
++)
1869 any
|= dump_switch_p_1 (arg
, &dump_files
[i
], true);
1871 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1872 any
|= dump_switch_p_1 (arg
, &m_extra_dump_files
[i
], false);
1875 for (i
= 0; i
< m_extra_dump_files_in_use
; i
++)
1876 any
|= dump_switch_p_1 (arg
, &m_extra_dump_files
[i
], true);
1882 /* Parse ARG as a -fopt-info switch and store flags, optgroup_flags
1883 and filename. Return non-zero if it is a recognized switch. */
1886 opt_info_switch_p_1 (const char *arg
, dump_flags_t
*flags
,
1887 optgroup_flags_t
*optgroup_flags
, char **filename
)
1889 const char *option_value
;
1897 /* Default to filtering out "internals" messages, and retaining
1898 "user-facing" messages, and those from an opt_problem being
1899 re-emitted at the top level. */
1900 *flags
= MSG_PRIORITY_USER_FACING
| MSG_PRIORITY_REEMITTED
;
1902 *optgroup_flags
= OPTGROUP_NONE
;
1905 return 1; /* Handle '-fopt-info' without any additional options. */
1909 const char *end_ptr
;
1915 end_ptr
= strchr (ptr
, '-');
1916 eq_ptr
= strchr (ptr
, '=');
1918 if (eq_ptr
&& (!end_ptr
|| eq_ptr
< end_ptr
))
1921 end_ptr
= ptr
+ strlen (ptr
);
1922 length
= end_ptr
- ptr
;
1924 for (const kv_pair
<dump_flags_t
> *option_ptr
= optinfo_verbosity_options
;
1925 option_ptr
->name
; option_ptr
++)
1926 if (strlen (option_ptr
->name
) == length
1927 && !memcmp (option_ptr
->name
, ptr
, length
))
1929 *flags
|= option_ptr
->value
;
1933 for (const kv_pair
<optgroup_flags_t
> *option_ptr
= optgroup_options
;
1934 option_ptr
->name
; option_ptr
++)
1935 if (strlen (option_ptr
->name
) == length
1936 && !memcmp (option_ptr
->name
, ptr
, length
))
1938 *optgroup_flags
|= option_ptr
->value
;
1944 /* Interpret rest of the argument as a dump filename. This
1945 filename overrides other command line filenames. */
1946 *filename
= xstrdup (ptr
+ 1);
1951 warning (0, "unknown option %q.*s in %<-fopt-info-%s%>",
1962 /* Return non-zero if ARG is a recognized switch for
1963 -fopt-info. Return zero otherwise. */
1966 opt_info_switch_p (const char *arg
)
1969 optgroup_flags_t optgroup_flags
;
1971 static char *file_seen
= NULL
;
1972 gcc::dump_manager
*dumps
= g
->get_dumps ();
1974 if (!opt_info_switch_p_1 (arg
, &flags
, &optgroup_flags
, &filename
))
1978 filename
= xstrdup ("stderr");
1980 /* Bail out if a different filename has been specified. */
1981 if (file_seen
&& strcmp (file_seen
, filename
))
1983 warning (0, "ignoring possibly conflicting option %<-fopt-info-%s%>",
1988 file_seen
= xstrdup (filename
);
1989 if (!(flags
& MSG_ALL_KINDS
))
1990 flags
|= MSG_OPTIMIZED_LOCATIONS
;
1991 if (!optgroup_flags
)
1992 optgroup_flags
= OPTGROUP_ALL
;
1994 return dumps
->opt_info_enable_passes (optgroup_flags
, flags
, filename
);
1997 /* Print basic block on the dump streams. */
2000 dump_basic_block (dump_flags_t dump_kind
, basic_block bb
, int indent
)
2003 && dump_context::get ().apply_dump_filter_p (dump_kind
, pflags
))
2004 dump_bb (dump_file
, bb
, indent
, TDF_DETAILS
);
2006 && dump_context::get ().apply_dump_filter_p (dump_kind
, alt_flags
))
2007 dump_bb (alt_dump_file
, bb
, indent
, TDF_DETAILS
);
2010 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
2013 dump_function (int phase
, tree fn
)
2018 stream
= dump_begin (phase
, &flags
);
2021 dump_function_to_file (fn
, stream
, flags
);
2022 dump_end (phase
, stream
);
2026 /* Print information from the combine pass on dump_file. */
2029 print_combine_total_stats (void)
2032 dump_combine_total_stats (dump_file
);
2035 /* Enable RTL dump for all the RTL passes. */
2038 enable_rtl_dump_file (void)
2040 gcc::dump_manager
*dumps
= g
->get_dumps ();
2042 dumps
->dump_enable_all (DK_rtl
, dump_flags_t (TDF_DETAILS
) | TDF_BLOCKS
,
2044 return num_enabled
> 0;
2049 namespace selftest
{
2051 /* temp_dump_context's ctor. Temporarily override the dump_context
2052 (to forcibly enable optinfo-generation). */
2054 temp_dump_context::temp_dump_context (bool forcibly_enable_optinfo
,
2055 bool forcibly_enable_dumping
,
2056 dump_flags_t test_pp_flags
)
2058 m_saved (&dump_context ().get ())
2060 dump_context::s_current
= &m_context
;
2061 if (forcibly_enable_optinfo
)
2062 m_context
.set_json_writer (new optrecord_json_writer ());
2063 /* Conditionally enable the test dump, so that we can verify both the
2064 dump_enabled_p and the !dump_enabled_p cases in selftests. */
2065 if (forcibly_enable_dumping
)
2067 m_context
.m_test_pp
= &m_pp
;
2068 m_context
.m_test_pp_flags
= test_pp_flags
;
2071 dump_context::get ().refresh_dumps_are_enabled ();
2074 /* temp_dump_context's dtor. Restore the saved dump_context. */
2076 temp_dump_context::~temp_dump_context ()
2078 m_context
.set_json_writer (NULL
);
2080 dump_context::s_current
= m_saved
;
2082 dump_context::get ().refresh_dumps_are_enabled ();
2085 /* 0-terminate the text dumped so far, and return it. */
2088 temp_dump_context::get_dumped_text ()
2090 return pp_formatted_text (&m_pp
);
2093 /* Verify that IMPL_LOC is within EXPECTED_FILE at EXPECTED_LINE,
2094 from EXPECTED_FUNCTION, using LOC for the location of any failure,
2095 provided that the build compiler is sufficiently recent. */
2098 assert_impl_location_eq (const location
&loc ATTRIBUTE_UNUSED
,
2099 const dump_impl_location_t
&impl_loc ATTRIBUTE_UNUSED
,
2100 const char *expected_file ATTRIBUTE_UNUSED
,
2101 int expected_line ATTRIBUTE_UNUSED
,
2102 const char *expected_function ATTRIBUTE_UNUSED
)
2104 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
2105 ASSERT_STR_CONTAINS_AT (loc
, impl_loc
.m_file
, expected_file
);
2106 ASSERT_EQ_AT (loc
, impl_loc
.m_line
, expected_line
);
2107 ASSERT_STR_CONTAINS_AT (loc
, impl_loc
.m_function
, expected_function
);
2111 /* Verify that IMPL_LOC is within EXPECTED_FILE at EXPECTED_LINE,
2112 from EXPECTED_FUNCTION, provided that the build compiler is
2113 sufficiently recent. */
2115 #define ASSERT_IMPL_LOCATION_EQ(IMPL_LOC, EXPECTED_FILE, EXPECTED_LINE, \
2116 EXPECTED_FUNCTION) \
2117 SELFTEST_BEGIN_STMT \
2118 assert_impl_location_eq (SELFTEST_LOCATION, IMPL_LOC, \
2119 EXPECTED_FILE, EXPECTED_LINE, \
2120 EXPECTED_FUNCTION); \
2123 /* Verify that the dump_location_t constructors capture the source location
2124 at which they were called (provided that the build compiler is sufficiently
2128 test_impl_location ()
2132 dump_location_t loc
;
2133 const int expected_line
= __LINE__
- 1;
2134 ASSERT_IMPL_LOCATION_EQ (loc
.get_impl_location (),
2135 "dumpfile.c", expected_line
, "test_impl_location");
2138 /* Constructing from a gimple. */
2140 dump_location_t
loc ((gimple
*)NULL
);
2141 const int expected_line
= __LINE__
- 1;
2142 ASSERT_IMPL_LOCATION_EQ (loc
.get_impl_location (),
2143 "dumpfile.c", expected_line
, "test_impl_location");
2146 /* Constructing from an rtx_insn. */
2148 dump_location_t
loc ((rtx_insn
*)NULL
);
2149 const int expected_line
= __LINE__
- 1;
2150 ASSERT_IMPL_LOCATION_EQ (loc
.get_impl_location (),
2151 "dumpfile.c", expected_line
, "test_impl_location");
2155 /* Verify that the text dumped so far in CONTEXT equals
2156 EXPECTED_TEXT, using LOC for the location of any failure.
2157 As a side-effect, the internal buffer is 0-terminated. */
2160 verify_dumped_text (const location
&loc
,
2161 temp_dump_context
*context
,
2162 const char *expected_text
)
2164 gcc_assert (context
);
2165 ASSERT_STREQ_AT (loc
, context
->get_dumped_text (),
2169 /* Verify that ITEM has the expected values. */
2172 verify_item (const location
&loc
,
2173 const optinfo_item
*item
,
2174 enum optinfo_item_kind expected_kind
,
2175 location_t expected_location
,
2176 const char *expected_text
)
2178 ASSERT_EQ_AT (loc
, item
->get_kind (), expected_kind
);
2179 ASSERT_EQ_AT (loc
, item
->get_location (), expected_location
);
2180 ASSERT_STREQ_AT (loc
, item
->get_text (), expected_text
);
2183 /* Verify that calls to the dump_* API are captured and consolidated into
2184 optimization records. */
2187 test_capture_of_dump_calls (const line_table_case
&case_
)
2189 /* Generate a location_t for testing. */
2190 line_table_test
ltt (case_
);
2191 linemap_add (line_table
, LC_ENTER
, false, "test.txt", 0);
2192 linemap_line_start (line_table
, 5, 100);
2193 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
2194 location_t decl_loc
= linemap_position_for_column (line_table
, 8);
2195 location_t stmt_loc
= linemap_position_for_column (line_table
, 10);
2196 if (stmt_loc
> LINE_MAP_MAX_LOCATION_WITH_COLS
)
2199 dump_user_location_t loc
= dump_user_location_t::from_location_t (stmt_loc
);
2201 gimple
*stmt
= gimple_build_return (NULL
);
2202 gimple_set_location (stmt
, stmt_loc
);
2204 tree test_decl
= build_decl (decl_loc
, FUNCTION_DECL
,
2205 get_identifier ("test_decl"),
2206 build_function_type_list (void_type_node
,
2209 symbol_table_test tmp_symtab
;
2211 cgraph_node
*node
= cgraph_node::get_create (test_decl
);
2214 /* Run all tests twice, with and then without optinfo enabled, to ensure
2215 that immediate destinations vs optinfo-based destinations both
2216 work, independently of each other, with no leaks. */
2217 for (int i
= 0 ; i
< 2; i
++)
2219 bool with_optinfo
= (i
== 0);
2221 /* Test of dump_printf. */
2223 temp_dump_context
tmp (with_optinfo
, true,
2224 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2225 dump_printf (MSG_NOTE
, "int: %i str: %s", 42, "foo");
2226 const int expected_impl_line
= __LINE__
- 1;
2228 ASSERT_DUMPED_TEXT_EQ (tmp
, "int: 42 str: foo");
2231 optinfo
*info
= tmp
.get_pending_optinfo ();
2232 ASSERT_TRUE (info
!= NULL
);
2233 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2234 ASSERT_EQ (info
->num_items (), 1);
2235 ASSERT_IS_TEXT (info
->get_item (0), "int: 42 str: foo");
2236 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2237 "dumpfile.c", expected_impl_line
,
2238 "test_capture_of_dump_calls");
2242 /* Test of dump_printf with %T. */
2244 temp_dump_context
tmp (with_optinfo
, true,
2245 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2246 dump_printf (MSG_NOTE
, "tree: %T", integer_zero_node
);
2247 const int expected_impl_line
= __LINE__
- 1;
2249 ASSERT_DUMPED_TEXT_EQ (tmp
, "tree: 0");
2252 optinfo
*info
= tmp
.get_pending_optinfo ();
2253 ASSERT_TRUE (info
!= NULL
);
2254 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2255 ASSERT_EQ (info
->num_items (), 2);
2256 ASSERT_IS_TEXT (info
->get_item (0), "tree: ");
2257 ASSERT_IS_TREE (info
->get_item (1), UNKNOWN_LOCATION
, "0");
2258 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2259 "dumpfile.c", expected_impl_line
,
2260 "test_capture_of_dump_calls");
2264 /* Test of dump_printf with %E. */
2266 temp_dump_context
tmp (with_optinfo
, true,
2267 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2268 dump_printf (MSG_NOTE
, "gimple: %E", stmt
);
2269 const int expected_impl_line
= __LINE__
- 1;
2271 ASSERT_DUMPED_TEXT_EQ (tmp
, "gimple: return;");
2274 optinfo
*info
= tmp
.get_pending_optinfo ();
2275 ASSERT_TRUE (info
!= NULL
);
2276 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2277 ASSERT_EQ (info
->num_items (), 2);
2278 ASSERT_IS_TEXT (info
->get_item (0), "gimple: ");
2279 ASSERT_IS_GIMPLE (info
->get_item (1), stmt_loc
, "return;");
2280 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2281 "dumpfile.c", expected_impl_line
,
2282 "test_capture_of_dump_calls");
2286 /* Test of dump_printf with %G. */
2288 temp_dump_context
tmp (with_optinfo
, true,
2289 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2290 dump_printf (MSG_NOTE
, "gimple: %G", stmt
);
2291 const int expected_impl_line
= __LINE__
- 1;
2293 ASSERT_DUMPED_TEXT_EQ (tmp
, "gimple: return;\n");
2296 optinfo
*info
= tmp
.get_pending_optinfo ();
2297 ASSERT_TRUE (info
!= NULL
);
2298 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2299 ASSERT_EQ (info
->num_items (), 2);
2300 ASSERT_IS_TEXT (info
->get_item (0), "gimple: ");
2301 ASSERT_IS_GIMPLE (info
->get_item (1), stmt_loc
, "return;\n");
2302 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2303 "dumpfile.c", expected_impl_line
,
2304 "test_capture_of_dump_calls");
2308 /* Test of dump_printf with %C. */
2310 temp_dump_context
tmp (with_optinfo
, true,
2311 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2312 dump_printf (MSG_NOTE
, "node: %C", node
);
2313 const int expected_impl_line
= __LINE__
- 1;
2315 ASSERT_DUMPED_TEXT_EQ (tmp
, "node: test_decl/0");
2318 optinfo
*info
= tmp
.get_pending_optinfo ();
2319 ASSERT_TRUE (info
!= NULL
);
2320 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2321 ASSERT_EQ (info
->num_items (), 2);
2322 ASSERT_IS_TEXT (info
->get_item (0), "node: ");
2323 ASSERT_IS_SYMTAB_NODE (info
->get_item (1), decl_loc
, "test_decl/0");
2324 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2325 "dumpfile.c", expected_impl_line
,
2326 "test_capture_of_dump_calls");
2330 /* dump_print_loc with multiple format codes. This tests various
2332 - intermingling of text, format codes handled by the base
2333 pretty_printer, and dump-specific format codes
2334 - multiple dump-specific format codes: some consecutive, others
2335 separated by text, trailing text after the final one. */
2337 temp_dump_context
tmp (with_optinfo
, true,
2338 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2339 dump_printf_loc (MSG_NOTE
, loc
, "before %T and %T"
2340 " %i consecutive %E%E after\n",
2341 integer_zero_node
, test_decl
, 42, stmt
, stmt
);
2343 ASSERT_DUMPED_TEXT_EQ (tmp
,
2344 "test.txt:5:10: note: before 0 and test_decl"
2345 " 42 consecutive return;return; after\n");
2348 optinfo
*info
= tmp
.get_pending_optinfo ();
2349 ASSERT_TRUE (info
!= NULL
);
2350 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2351 ASSERT_EQ (info
->num_items (), 8);
2352 ASSERT_IS_TEXT (info
->get_item (0), "before ");
2353 ASSERT_IS_TREE (info
->get_item (1), UNKNOWN_LOCATION
, "0");
2354 ASSERT_IS_TEXT (info
->get_item (2), " and ");
2355 ASSERT_IS_TREE (info
->get_item (3), UNKNOWN_LOCATION
, "test_decl");
2356 ASSERT_IS_TEXT (info
->get_item (4), " 42 consecutive ");
2357 ASSERT_IS_GIMPLE (info
->get_item (5), stmt_loc
, "return;");
2358 ASSERT_IS_GIMPLE (info
->get_item (6), stmt_loc
, "return;");
2359 ASSERT_IS_TEXT (info
->get_item (7), " after\n");
2360 /* We don't ASSERT_IMPL_LOCATION_EQ here, to avoid having to
2361 enforce at which exact line the multiline dump_printf_loc
2366 /* Tree, via dump_generic_expr. */
2368 temp_dump_context
tmp (with_optinfo
, true,
2369 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2370 dump_printf_loc (MSG_NOTE
, loc
, "test of tree: ");
2371 const int expected_impl_line
= __LINE__
- 1;
2372 dump_generic_expr (MSG_NOTE
, TDF_SLIM
, integer_zero_node
);
2374 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: test of tree: 0");
2377 optinfo
*info
= tmp
.get_pending_optinfo ();
2378 ASSERT_TRUE (info
!= NULL
);
2379 ASSERT_EQ (info
->get_location_t (), stmt_loc
);
2380 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2381 ASSERT_EQ (info
->num_items (), 2);
2382 ASSERT_IS_TEXT (info
->get_item (0), "test of tree: ");
2383 ASSERT_IS_TREE (info
->get_item (1), UNKNOWN_LOCATION
, "0");
2384 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2385 "dumpfile.c", expected_impl_line
,
2386 "test_capture_of_dump_calls");
2390 /* Tree, via dump_generic_expr_loc. */
2392 temp_dump_context
tmp (with_optinfo
, true,
2393 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2394 dump_generic_expr_loc (MSG_NOTE
, loc
, TDF_SLIM
, integer_one_node
);
2395 const int expected_impl_line
= __LINE__
- 1;
2397 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: 1");
2400 optinfo
*info
= tmp
.get_pending_optinfo ();
2401 ASSERT_TRUE (info
!= NULL
);
2402 ASSERT_EQ (info
->get_location_t (), stmt_loc
);
2403 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2404 ASSERT_EQ (info
->num_items (), 1);
2405 ASSERT_IS_TREE (info
->get_item (0), UNKNOWN_LOCATION
, "1");
2406 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2407 "dumpfile.c", expected_impl_line
,
2408 "test_capture_of_dump_calls");
2414 /* dump_gimple_stmt_loc. */
2416 temp_dump_context
tmp (with_optinfo
, true,
2417 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2418 dump_gimple_stmt_loc (MSG_NOTE
, loc
, TDF_SLIM
, stmt
, 2);
2419 const int expected_impl_line
= __LINE__
- 1;
2421 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: return;\n");
2424 optinfo
*info
= tmp
.get_pending_optinfo ();
2425 ASSERT_TRUE (info
!= NULL
);
2426 ASSERT_EQ (info
->num_items (), 1);
2427 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;\n");
2428 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2429 "dumpfile.c", expected_impl_line
,
2430 "test_capture_of_dump_calls");
2434 /* dump_gimple_stmt. */
2436 temp_dump_context
tmp (with_optinfo
, true,
2437 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2438 dump_gimple_stmt (MSG_NOTE
, TDF_SLIM
, stmt
, 2);
2439 const int expected_impl_line
= __LINE__
- 1;
2441 ASSERT_DUMPED_TEXT_EQ (tmp
, "return;\n");
2444 optinfo
*info
= tmp
.get_pending_optinfo ();
2445 ASSERT_TRUE (info
!= NULL
);
2446 ASSERT_EQ (info
->num_items (), 1);
2447 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;\n");
2448 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2449 "dumpfile.c", expected_impl_line
,
2450 "test_capture_of_dump_calls");
2454 /* dump_gimple_expr_loc. */
2456 temp_dump_context
tmp (with_optinfo
, true,
2457 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2458 dump_gimple_expr_loc (MSG_NOTE
, loc
, TDF_SLIM
, stmt
, 2);
2459 const int expected_impl_line
= __LINE__
- 1;
2461 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: note: return;");
2464 optinfo
*info
= tmp
.get_pending_optinfo ();
2465 ASSERT_TRUE (info
!= NULL
);
2466 ASSERT_EQ (info
->num_items (), 1);
2467 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;");
2468 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2469 "dumpfile.c", expected_impl_line
,
2470 "test_capture_of_dump_calls");
2474 /* dump_gimple_expr. */
2476 temp_dump_context
tmp (with_optinfo
, true,
2477 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2478 dump_gimple_expr (MSG_NOTE
, TDF_SLIM
, stmt
, 2);
2479 const int expected_impl_line
= __LINE__
- 1;
2481 ASSERT_DUMPED_TEXT_EQ (tmp
, "return;");
2484 optinfo
*info
= tmp
.get_pending_optinfo ();
2485 ASSERT_TRUE (info
!= NULL
);
2486 ASSERT_EQ (info
->num_items (), 1);
2487 ASSERT_IS_GIMPLE (info
->get_item (0), stmt_loc
, "return;");
2488 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2489 "dumpfile.c", expected_impl_line
,
2490 "test_capture_of_dump_calls");
2497 temp_dump_context
tmp (with_optinfo
, true,
2498 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2499 dump_symtab_node (MSG_NOTE
, node
);
2500 const int expected_impl_line
= __LINE__
- 1;
2502 ASSERT_DUMPED_TEXT_EQ (tmp
, "test_decl/0");
2505 optinfo
*info
= tmp
.get_pending_optinfo ();
2506 ASSERT_TRUE (info
!= NULL
);
2507 ASSERT_EQ (info
->get_kind (), OPTINFO_KIND_NOTE
);
2508 ASSERT_EQ (info
->num_items (), 1);
2509 ASSERT_IS_SYMTAB_NODE (info
->get_item (0), decl_loc
, "test_decl/0");
2510 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2511 "dumpfile.c", expected_impl_line
,
2512 "test_capture_of_dump_calls");
2518 temp_dump_context
tmp (with_optinfo
, true,
2519 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2520 dump_dec (MSG_NOTE
, poly_int64 (42));
2521 const int expected_impl_line
= __LINE__
- 1;
2523 ASSERT_DUMPED_TEXT_EQ (tmp
, "42");
2526 optinfo
*info
= tmp
.get_pending_optinfo ();
2527 ASSERT_TRUE (info
!= NULL
);
2528 ASSERT_EQ (info
->num_items (), 1);
2529 ASSERT_IS_TEXT (info
->get_item (0), "42");
2530 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2531 "dumpfile.c", expected_impl_line
,
2532 "test_capture_of_dump_calls");
2536 /* Scopes. Test with all 4 combinations of
2537 filtering by MSG_PRIORITY_USER_FACING
2538 and/or filtering by MSG_PRIORITY_INTERNALS. */
2539 for (int j
= 0; j
< 3; j
++)
2541 dump_flags_t dump_filter
= MSG_ALL_KINDS
;
2543 dump_filter
|= MSG_PRIORITY_USER_FACING
;
2545 dump_filter
|= MSG_PRIORITY_INTERNALS
;
2547 temp_dump_context
tmp (with_optinfo
, true, dump_filter
);
2548 /* Emit various messages, mostly with implicit priority. */
2549 dump_printf_loc (MSG_NOTE
, stmt
, "msg 1\n");
2550 dump_printf_loc (MSG_NOTE
| MSG_PRIORITY_INTERNALS
, stmt
,
2551 "explicitly internal msg\n");
2553 AUTO_DUMP_SCOPE ("outer scope", stmt
);
2554 dump_printf_loc (MSG_NOTE
, stmt
, "msg 2\n");
2556 AUTO_DUMP_SCOPE ("middle scope", stmt
);
2557 dump_printf_loc (MSG_NOTE
, stmt
, "msg 3\n");
2559 AUTO_DUMP_SCOPE ("inner scope", stmt
);
2560 dump_printf_loc (MSG_NOTE
, stmt
, "msg 4\n");
2561 dump_printf_loc (MSG_NOTE
| MSG_PRIORITY_USER_FACING
, stmt
,
2562 "explicitly user-facing msg\n");
2564 dump_printf_loc (MSG_NOTE
, stmt
, "msg 5\n");
2566 dump_printf_loc (MSG_NOTE
, stmt
, "msg 6\n");
2568 dump_printf_loc (MSG_NOTE
, stmt
, "msg 7\n");
2569 const int expected_impl_line
= __LINE__
- 1;
2571 switch (dump_filter
& MSG_ALL_PRIORITIES
)
2576 ASSERT_DUMPED_TEXT_EQ (tmp
, "");
2578 case MSG_PRIORITY_USER_FACING
:
2579 ASSERT_DUMPED_TEXT_EQ
2581 "test.txt:5:10: note: msg 1\n"
2582 "test.txt:5:10: note: explicitly user-facing msg\n"
2583 "test.txt:5:10: note: msg 7\n");
2585 case MSG_PRIORITY_INTERNALS
:
2586 ASSERT_DUMPED_TEXT_EQ
2588 "test.txt:5:10: note: explicitly internal msg\n"
2589 "test.txt:5:10: note: === outer scope ===\n"
2590 "test.txt:5:10: note: msg 2\n"
2591 "test.txt:5:10: note: === middle scope ===\n"
2592 "test.txt:5:10: note: msg 3\n"
2593 "test.txt:5:10: note: === inner scope ===\n"
2594 "test.txt:5:10: note: msg 4\n"
2595 "test.txt:5:10: note: msg 5\n"
2596 "test.txt:5:10: note: msg 6\n");
2598 case MSG_ALL_PRIORITIES
:
2599 ASSERT_DUMPED_TEXT_EQ
2601 "test.txt:5:10: note: msg 1\n"
2602 "test.txt:5:10: note: explicitly internal msg\n"
2603 "test.txt:5:10: note: === outer scope ===\n"
2604 "test.txt:5:10: note: msg 2\n"
2605 "test.txt:5:10: note: === middle scope ===\n"
2606 "test.txt:5:10: note: msg 3\n"
2607 "test.txt:5:10: note: === inner scope ===\n"
2608 "test.txt:5:10: note: msg 4\n"
2609 "test.txt:5:10: note: explicitly user-facing msg\n"
2610 "test.txt:5:10: note: msg 5\n"
2611 "test.txt:5:10: note: msg 6\n"
2612 "test.txt:5:10: note: msg 7\n");
2617 optinfo
*info
= tmp
.get_pending_optinfo ();
2618 ASSERT_TRUE (info
!= NULL
);
2619 ASSERT_EQ (info
->num_items (), 1);
2620 ASSERT_IS_TEXT (info
->get_item (0), "msg 7\n");
2621 ASSERT_IMPL_LOCATION_EQ (info
->get_impl_location (),
2622 "dumpfile.c", expected_impl_line
,
2623 "test_capture_of_dump_calls");
2628 /* Verify that MSG_* affects optinfo->get_kind (); we tested MSG_NOTE
2631 /* MSG_OPTIMIZED_LOCATIONS. */
2633 temp_dump_context
tmp (true, true, MSG_ALL_KINDS
);
2634 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
, "test");
2635 ASSERT_EQ (tmp
.get_pending_optinfo ()->get_kind (),
2636 OPTINFO_KIND_SUCCESS
);
2639 /* MSG_MISSED_OPTIMIZATION. */
2641 temp_dump_context
tmp (true, true, MSG_ALL_KINDS
);
2642 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
, "test");
2643 ASSERT_EQ (tmp
.get_pending_optinfo ()->get_kind (),
2644 OPTINFO_KIND_FAILURE
);
2648 /* Verify that MSG_* affect AUTO_DUMP_SCOPE and the dump calls. */
2650 temp_dump_context
tmp (false, true,
2651 MSG_OPTIMIZED_LOCATIONS
| MSG_ALL_PRIORITIES
);
2652 dump_printf_loc (MSG_NOTE
, stmt
, "msg 1\n");
2654 AUTO_DUMP_SCOPE ("outer scope", stmt
);
2655 dump_printf_loc (MSG_NOTE
, stmt
, "msg 2\n");
2657 AUTO_DUMP_SCOPE ("middle scope", stmt
);
2658 dump_printf_loc (MSG_NOTE
, stmt
, "msg 3\n");
2660 AUTO_DUMP_SCOPE ("inner scope", stmt
);
2661 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
, "msg 4\n");
2663 dump_printf_loc (MSG_NOTE
, stmt
, "msg 5\n");
2665 dump_printf_loc (MSG_NOTE
, stmt
, "msg 6\n");
2667 dump_printf_loc (MSG_NOTE
, stmt
, "msg 7\n");
2669 ASSERT_DUMPED_TEXT_EQ (tmp
, "test.txt:5:10: optimized: msg 4\n");
2676 dump_user_location_t loc
2677 = dump_user_location_t::from_location_t (UNKNOWN_LOCATION
);
2679 temp_dump_context
tmp (true, true,
2680 MSG_ALL_KINDS
| MSG_PRIORITY_USER_FACING
);
2682 AUTO_DUMP_SCOPE ("outer scope", loc
);
2683 dump_printf (MSG_NOTE
, "msg1\n");
2687 /* Run all of the selftests within this file. */
2692 test_impl_location ();
2693 for_each_line_table_case (test_capture_of_dump_calls
);
2697 } // namespace selftest
2699 #endif /* CHECKING_P */