Line data Source code
1 : /* Definitions for the shared dumpfile.
2 : Copyright (C) 2004-2026 Free Software Foundation, Inc.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify
7 : it under the terms of the GNU General Public License as published by
8 : the Free Software Foundation; either version 3, or (at your option)
9 : any later version.
10 :
11 : GCC is distributed in the hope that it will be useful,
12 : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : GNU General Public License for more details.
15 :
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/>. */
19 :
20 :
21 : #ifndef GCC_DUMPFILE_H
22 : #define GCC_DUMPFILE_H 1
23 :
24 : #include "profile-count.h"
25 :
26 : /* An attribute for annotating formatting printing functions that use
27 : the dumpfile/optinfo formatting codes. These are the pretty_printer
28 : format codes (see pretty-print.cc), with additional codes for middle-end
29 : specific entities (see dumpfile.cc). */
30 :
31 : #if GCC_VERSION >= 9000
32 : #define ATTRIBUTE_GCC_DUMP_PRINTF(m, n) \
33 : __attribute__ ((__format__ (__gcc_dump_printf__, m ,n))) \
34 : ATTRIBUTE_NONNULL(m)
35 : #else
36 : #define ATTRIBUTE_GCC_DUMP_PRINTF(m, n) ATTRIBUTE_NONNULL(m)
37 : #endif
38 :
39 : /* Different tree dump places. When you add new tree dump places,
40 : extend the DUMP_FILES array in dumpfile.cc. */
41 : enum tree_dump_index
42 : {
43 : TDI_none, /* No dump */
44 : TDI_cgraph, /* dump function call graph. */
45 : TDI_inheritance, /* dump type inheritance graph. */
46 : TDI_clones, /* dump IPA cloning decisions. */
47 : TDI_original, /* dump each function before optimizing it */
48 : TDI_gimple, /* dump each function after gimplifying it */
49 : TDI_nested, /* dump each function after unnesting it */
50 : TDI_lto_stream_out, /* dump information about lto streaming */
51 : TDI_profile_report, /* dump information about profile quality */
52 :
53 : TDI_lang_all, /* enable all the language dumps. */
54 : TDI_tree_all, /* enable all the GENERIC/GIMPLE dumps. */
55 : TDI_rtl_all, /* enable all the RTL dumps. */
56 : TDI_ipa_all, /* enable all the IPA dumps. */
57 :
58 : TDI_end
59 : };
60 :
61 : /* Enum used to distinguish dump files to types. */
62 :
63 : enum dump_kind
64 : {
65 : DK_none,
66 : DK_lang,
67 : DK_tree,
68 : DK_rtl,
69 : DK_ipa
70 : };
71 :
72 : /* Bit masks to control dumping. Not all values are applicable to all
73 : dumps. Add new ones at the end. When you define new values, extend
74 : the DUMP_OPTIONS array in dumpfile.cc. The TDF_* flags coexist with
75 : MSG_* flags (for -fopt-info) and the bit values must be chosen to
76 : allow that. */
77 : enum dump_flag : uint32_t
78 : {
79 : /* Value of TDF_NONE is used just for bits filtered by TDF_KIND_MASK. */
80 : TDF_NONE = 0,
81 :
82 : /* Dump node addresses. */
83 : TDF_ADDRESS = (1 << 0),
84 :
85 : /* Don't go wild following links. */
86 : TDF_SLIM = (1 << 1),
87 :
88 : /* Don't unparse the function. */
89 : TDF_RAW = (1 << 2),
90 :
91 : /* Show more detailed info about each pass. */
92 : TDF_DETAILS = (1 << 3),
93 :
94 : /* Dump various statistics about each pass. */
95 : TDF_STATS = (1 << 4),
96 :
97 : /* Display basic block boundaries. */
98 : TDF_BLOCKS = (1 << 5),
99 :
100 : /* Display virtual operands. */
101 : TDF_VOPS = (1 << 6),
102 :
103 : /* Display statement line numbers. */
104 : TDF_LINENO = (1 << 7),
105 :
106 : /* Display decl UIDs. */
107 : TDF_UID = (1 << 8),
108 :
109 : /* Address of stmt. */
110 : TDF_STMTADDR = (1 << 9),
111 :
112 : /* A graph dump is being emitted. */
113 : TDF_GRAPH = (1 << 10),
114 :
115 : /* Display memory symbols in expr.
116 : Implies TDF_VOPS. */
117 : TDF_MEMSYMS = (1 << 11),
118 :
119 : /* A flag to only print the RHS of a gimple stmt. */
120 : TDF_RHS_ONLY = (1 << 12),
121 :
122 : /* Display asm names of decls. */
123 : TDF_ASMNAME = (1 << 13),
124 :
125 : /* Display EH region number holding this gimple statement. */
126 : TDF_EH = (1 << 14),
127 :
128 : /* Omit UIDs from dumps. */
129 : TDF_NOUID = (1 << 15),
130 :
131 : /* Display alias information. */
132 : TDF_ALIAS = (1 << 16),
133 :
134 : /* Enumerate locals by uid. */
135 : TDF_ENUMERATE_LOCALS = (1 << 17),
136 :
137 : /* Dump cselib details. */
138 : TDF_CSELIB = (1 << 18),
139 :
140 : /* Dump SCEV details. */
141 : TDF_SCEV = (1 << 19),
142 :
143 : /* Dump in GIMPLE FE syntax. */
144 : TDF_GIMPLE = (1 << 20),
145 :
146 : /* Dump folding details. */
147 : TDF_FOLDING = (1 << 21),
148 :
149 : /* MSG_* flags for expressing the kinds of message to
150 : be emitted by -fopt-info. */
151 :
152 : /* -fopt-info optimized sources. */
153 : MSG_OPTIMIZED_LOCATIONS = (1 << 22),
154 :
155 : /* Missed opportunities. */
156 : MSG_MISSED_OPTIMIZATION = (1 << 23),
157 :
158 : /* General optimization info. */
159 : MSG_NOTE = (1 << 24),
160 :
161 : /* Mask for selecting MSG_-kind flags. */
162 : MSG_ALL_KINDS = (MSG_OPTIMIZED_LOCATIONS
163 : | MSG_MISSED_OPTIMIZATION
164 : | MSG_NOTE),
165 :
166 : /* MSG_PRIORITY_* flags for expressing the priority levels of message
167 : to be emitted by -fopt-info, and filtering on them.
168 : By default, messages at the top-level dump scope are "user-facing",
169 : whereas those that are in nested scopes are implicitly "internals".
170 : This behavior can be overridden for a given dump message by explicitly
171 : specifying one of the MSG_PRIORITY_* flags.
172 :
173 : By default, dump files show both kinds of message, whereas -fopt-info
174 : only shows "user-facing" messages, and requires the "-internals"
175 : sub-option of -fopt-info to show the internal messages. */
176 :
177 : /* Implicitly supplied for messages at the top-level dump scope. */
178 : MSG_PRIORITY_USER_FACING = (1 << 25),
179 :
180 : /* Implicitly supplied for messages within nested dump scopes. */
181 : MSG_PRIORITY_INTERNALS = (1 << 26),
182 :
183 : /* Supplied when an opt_problem generated in a nested scope is re-emitted
184 : at the top-level. We want to default to showing these in -fopt-info
185 : output, but to *not* show them in dump files, as the message would be
186 : shown twice, messing up "scan-tree-dump-times" in DejaGnu tests. */
187 : MSG_PRIORITY_REEMITTED = (1 << 27),
188 :
189 : /* Mask for selecting MSG_PRIORITY_* flags. */
190 : MSG_ALL_PRIORITIES = (MSG_PRIORITY_USER_FACING
191 : | MSG_PRIORITY_INTERNALS
192 : | MSG_PRIORITY_REEMITTED),
193 :
194 : /* All -fdump- flags. */
195 : TDF_ALL_VALUES = (1 << 28) - 1,
196 :
197 : /* Dumping for -fcompare-debug. */
198 : TDF_COMPARE_DEBUG = (1 << 28),
199 :
200 : /* Dump a GIMPLE value which means wrapping certain things with _Literal. */
201 : TDF_GIMPLE_VAL = (1 << 29),
202 :
203 : /* For error. */
204 : TDF_ERROR = ((uint32_t)1 << 30),
205 : };
206 :
207 : /* Dump flags type. */
208 :
209 : typedef enum dump_flag dump_flags_t;
210 :
211 : inline dump_flags_t
212 2140965 : operator| (dump_flags_t lhs, dump_flags_t rhs)
213 : {
214 1236118 : return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
215 2140965 : | (std::underlying_type<dump_flags_t>::type)rhs);
216 : }
217 :
218 : inline dump_flags_t
219 565443268 : operator& (dump_flags_t lhs, dump_flags_t rhs)
220 : {
221 565443815 : return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
222 498281195 : & (std::underlying_type<dump_flags_t>::type)rhs);
223 : }
224 :
225 : inline dump_flags_t
226 0 : operator~ (dump_flags_t flags)
227 : {
228 0 : return (dump_flags_t)~((std::underlying_type<dump_flags_t>::type)flags);
229 : }
230 :
231 : inline dump_flags_t &
232 24507240 : operator|= (dump_flags_t &lhs, dump_flags_t rhs)
233 : {
234 24507240 : lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
235 24484209 : | (std::underlying_type<dump_flags_t>::type)rhs);
236 24507240 : return lhs;
237 : }
238 :
239 : inline dump_flags_t &
240 986 : operator&= (dump_flags_t &lhs, dump_flags_t rhs)
241 : {
242 986 : lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
243 986 : & (std::underlying_type<dump_flags_t>::type)rhs);
244 986 : return lhs;
245 : }
246 :
247 : /* Flags to control high-level -fopt-info dumps. Usually these flags
248 : define a group of passes. An optimization pass can be part of
249 : multiple groups. */
250 :
251 : enum optgroup_flag
252 : {
253 : OPTGROUP_NONE = 0,
254 :
255 : /* IPA optimization passes */
256 : OPTGROUP_IPA = (1 << 1),
257 :
258 : /* Loop optimization passes */
259 : OPTGROUP_LOOP = (1 << 2),
260 :
261 : /* Inlining passes */
262 : OPTGROUP_INLINE = (1 << 3),
263 :
264 : /* OMP (Offloading and Multi Processing) transformations */
265 : OPTGROUP_OMP = (1 << 4),
266 :
267 : /* Vectorization passes */
268 : OPTGROUP_VEC = (1 << 5),
269 :
270 : /* All other passes */
271 : OPTGROUP_OTHER = (1 << 6),
272 :
273 : OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE
274 : | OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
275 : };
276 :
277 : typedef enum optgroup_flag optgroup_flags_t;
278 :
279 : inline optgroup_flags_t
280 : operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
281 : {
282 : return (optgroup_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
283 : | (std::underlying_type<dump_flags_t>::type)rhs);
284 : }
285 :
286 : inline optgroup_flags_t &
287 103717919 : operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
288 : {
289 103717919 : lhs = (optgroup_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
290 103717919 : | (std::underlying_type<dump_flags_t>::type)rhs);
291 103717919 : return lhs;
292 : }
293 :
294 : /* Define a tree dump switch. */
295 : struct dump_file_info
296 : {
297 : /* Suffix to give output file. */
298 : const char *suffix;
299 : /* Command line dump switch. */
300 : const char *swtch;
301 : /* Command line glob. */
302 : const char *glob;
303 : /* Filename for the pass-specific stream. */
304 : const char *pfilename;
305 : /* Filename for the -fopt-info stream. */
306 : const char *alt_filename;
307 : /* Pass-specific dump stream. */
308 : FILE *pstream;
309 : /* -fopt-info stream. */
310 : FILE *alt_stream;
311 : /* Dump kind. */
312 : dump_kind dkind;
313 : /* Dump flags. */
314 : dump_flags_t pflags;
315 : /* A pass flags for -fopt-info. */
316 : dump_flags_t alt_flags;
317 : /* Flags for -fopt-info given by a user. */
318 : optgroup_flags_t optgroup_flags;
319 : /* State of pass-specific stream. */
320 : int pstate;
321 : /* State of the -fopt-info stream. */
322 : int alt_state;
323 : /* Dump file number. */
324 : int num;
325 : /* Fields "suffix", "swtch", "glob" can be const strings,
326 : or can be dynamically allocated, needing free. */
327 : bool owns_strings;
328 : /* When a given dump file is being initialized, this flag is set to true
329 : if the corresponding TDF_graph dump file has also been initialized. */
330 : bool graph_dump_initialized;
331 : };
332 :
333 : /* A class for describing where in the user's source that a dump message
334 : relates to, with various constructors for convenience.
335 : In particular, this lets us associate dump messages
336 : with hotness information (e.g. from PGO), allowing them to
337 : be prioritized by code hotness. */
338 :
339 : class dump_user_location_t
340 : {
341 : public:
342 : /* Default constructor, analogous to UNKNOWN_LOCATION. */
343 328623 : dump_user_location_t () : m_count (), m_loc (UNKNOWN_LOCATION) {}
344 :
345 : /* Construct from a gimple statement (using its location and hotness). */
346 : dump_user_location_t (const gimple *stmt);
347 :
348 : /* Construct from an RTL instruction (using its location and hotness). */
349 : dump_user_location_t (const rtx_insn *insn);
350 :
351 : /* Construct from a location_t. This one is deprecated (since it doesn't
352 : capture hotness information); it thus needs to be spelled out. */
353 : static dump_user_location_t
354 22914 : from_location_t (location_t loc)
355 : {
356 22914 : return dump_user_location_t (profile_count (), loc);
357 : }
358 :
359 : /* Construct from a function declaration. This one requires spelling out
360 : to avoid accidentally constructing from other kinds of tree. */
361 : static dump_user_location_t
362 : from_function_decl (tree fndecl);
363 :
364 42780 : profile_count get_count () const { return m_count; }
365 7944969 : location_t get_location_t () const { return m_loc; }
366 :
367 : private:
368 : /* Private ctor from count and location, for use by from_location_t. */
369 22914 : dump_user_location_t (profile_count count, location_t loc)
370 : : m_count (count), m_loc (loc)
371 : {}
372 :
373 : profile_count m_count;
374 : location_t m_loc;
375 : };
376 :
377 : /* A class for identifying where in the compiler's own source
378 : (or a plugin) that a dump message is being emitted from. */
379 :
380 : class dump_impl_location_t
381 : {
382 : public:
383 1992706 : dump_impl_location_t (
384 : #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
385 : const char *file = __builtin_FILE (),
386 : int line = __builtin_LINE (),
387 : const char *function = __builtin_FUNCTION ()
388 : #else
389 : const char *file = __FILE__,
390 : int line = __LINE__,
391 : const char *function = NULL
392 : #endif
393 : )
394 19864286 : : m_file (file), m_line (line), m_function (function)
395 75282 : {}
396 :
397 : const char *m_file;
398 : int m_line;
399 : const char *m_function;
400 : };
401 :
402 : /* A bundle of metadata for describing a dump message:
403 : (a) the dump_flags
404 : (b) the source location within the compiler/plugin.
405 :
406 : The constructors use default parameters so that (b) gets sets up
407 : automatically.
408 :
409 : Hence you can pass in e.g. MSG_NOTE, and the dump call
410 : will automatically record where in GCC's source code the
411 : dump was emitted from. */
412 :
413 : class dump_metadata_t
414 : {
415 : public:
416 9470858 : dump_metadata_t (dump_flags_t dump_flags,
417 : const dump_impl_location_t &impl_location
418 : = dump_impl_location_t ())
419 9470858 : : m_dump_flags (dump_flags),
420 8910166 : m_impl_location (impl_location)
421 : {
422 10190 : }
423 :
424 18616031 : dump_flags_t get_dump_flags () const { return m_dump_flags; }
425 :
426 : const dump_impl_location_t &
427 : get_impl_location () const { return m_impl_location; }
428 :
429 : private:
430 : dump_flags_t m_dump_flags;
431 : dump_impl_location_t m_impl_location;
432 : };
433 :
434 : /* A bundle of information for describing the location of a dump message:
435 : (a) the source location and hotness within the user's code, together with
436 : (b) the source location within the compiler/plugin.
437 :
438 : The constructors use default parameters so that (b) gets sets up
439 : automatically.
440 :
441 : The upshot is that you can pass in e.g. a gimple * to dump_printf_loc,
442 : and the dump call will automatically record where in GCC's source
443 : code the dump was emitted from. */
444 :
445 : class dump_location_t
446 : {
447 : public:
448 : /* Default constructor, analogous to UNKNOWN_LOCATION. */
449 60 : dump_location_t (const dump_impl_location_t &impl_location
450 : = dump_impl_location_t ())
451 60 : : m_user_location (dump_user_location_t ()),
452 60 : m_impl_location (impl_location)
453 : {
454 : }
455 :
456 : /* Construct from a gimple statement (using its location and hotness). */
457 6783738 : dump_location_t (const gimple *stmt,
458 : const dump_impl_location_t &impl_location
459 : = dump_impl_location_t ())
460 6783738 : : m_user_location (dump_user_location_t (stmt)),
461 6783738 : m_impl_location (impl_location)
462 : {
463 : }
464 :
465 : /* Construct from an RTL instruction (using its location and hotness). */
466 4 : dump_location_t (const rtx_insn *insn,
467 : const dump_impl_location_t &impl_location
468 : = dump_impl_location_t ())
469 4 : : m_user_location (dump_user_location_t (insn)),
470 4 : m_impl_location (impl_location)
471 : {
472 : }
473 :
474 : /* Construct from a dump_user_location_t. */
475 1102127 : dump_location_t (const dump_user_location_t &user_location,
476 : const dump_impl_location_t &impl_location
477 : = dump_impl_location_t ())
478 1102127 : : m_user_location (user_location),
479 1102127 : m_impl_location (impl_location)
480 : {
481 : }
482 :
483 : /* Construct from a location_t. This one is deprecated (since it doesn't
484 : capture hotness information), and thus requires spelling out. */
485 : static dump_location_t
486 0 : from_location_t (location_t loc,
487 : const dump_impl_location_t &impl_location
488 : = dump_impl_location_t ())
489 : {
490 0 : return dump_location_t (dump_user_location_t::from_location_t (loc),
491 0 : impl_location);
492 : }
493 :
494 : const dump_user_location_t &
495 32703 : get_user_location () const { return m_user_location; }
496 :
497 : const dump_impl_location_t &
498 43688 : get_impl_location () const { return m_impl_location; }
499 :
500 43228 : location_t get_location_t () const
501 : {
502 43228 : return m_user_location.get_location_t ();
503 : }
504 :
505 42780 : profile_count get_count () const { return m_user_location.get_count (); }
506 :
507 : private:
508 : dump_user_location_t m_user_location;
509 : dump_impl_location_t m_impl_location;
510 : };
511 :
512 : /* In dumpfile.cc */
513 : extern FILE *dump_begin (int, dump_flags_t *, int part=-1);
514 : extern void dump_end (int, FILE *);
515 : extern int opt_info_switch_p (const char *);
516 : extern const char *dump_flag_name (int);
517 : extern const kv_pair<optgroup_flags_t> optgroup_options[];
518 : extern dump_flags_t
519 : parse_dump_option (const char *, const char **);
520 :
521 : /* Global variables used to communicate with passes. */
522 : extern FILE *dump_file;
523 : extern dump_flags_t dump_flags;
524 : extern const char *dump_file_name;
525 :
526 : extern bool dumps_are_enabled;
527 :
528 : extern void set_dump_file (FILE *new_dump_file);
529 :
530 : /* Return true if any of the dumps is enabled, false otherwise. */
531 : inline bool
532 330779177 : dump_enabled_p (void)
533 : {
534 290238111 : return dumps_are_enabled;
535 : }
536 :
537 : /* The following API calls (which *don't* take a "FILE *")
538 : write the output to zero or more locations.
539 :
540 : Some destinations are written to immediately as dump_* calls
541 : are made; for others, the output is consolidated into an "optinfo"
542 : instance (with its own metadata), and only emitted once the optinfo
543 : is complete.
544 :
545 : The destinations are:
546 :
547 : (a) the "immediate" destinations:
548 : (a.1) the active dump_file, if any
549 : (a.2) the -fopt-info destination, if any
550 : (b) the "optinfo" destinations, if any:
551 : (b.1) as optimization records
552 :
553 : dump_* (MSG_*) --> dumpfile.cc --> items --> (a.1) dump_file
554 : | `-> (a.2) alt_dump_file
555 : |
556 : `--> (b) optinfo
557 : `---> optinfo destinations
558 : (b.1) optimization records
559 :
560 : For optinfos, the dump_*_loc mark the beginning of an optinfo
561 : instance: all subsequent dump_* calls are consolidated into
562 : that optinfo, until the next dump_*_loc call (or a change in
563 : dump scope, or a call to dumpfile_ensure_any_optinfo_are_flushed).
564 :
565 : A group of dump_* calls should be guarded by:
566 :
567 : if (dump_enabled_p ())
568 :
569 : to minimize the work done for the common case where dumps
570 : are disabled. */
571 :
572 : extern void dump_printf (const dump_metadata_t &, const char *, ...)
573 : ATTRIBUTE_GCC_DUMP_PRINTF (2, 3);
574 :
575 : extern void dump_printf_loc (const dump_metadata_t &, const dump_user_location_t &,
576 : const char *, ...)
577 : ATTRIBUTE_GCC_DUMP_PRINTF (3, 4);
578 : extern void dump_function (int phase, tree fn);
579 : extern void dump_basic_block (dump_flags_t, basic_block, int);
580 : extern void dump_generic_expr_loc (const dump_metadata_t &,
581 : const dump_user_location_t &,
582 : dump_flags_t, tree);
583 : extern void dump_generic_expr (const dump_metadata_t &, dump_flags_t, tree);
584 : extern void dump_gimple_stmt_loc (const dump_metadata_t &,
585 : const dump_user_location_t &,
586 : dump_flags_t, gimple *, int);
587 : extern void dump_gimple_stmt (const dump_metadata_t &, dump_flags_t, gimple *, int);
588 : extern void dump_gimple_expr_loc (const dump_metadata_t &,
589 : const dump_user_location_t &,
590 : dump_flags_t, gimple *, int);
591 : extern void dump_gimple_expr (const dump_metadata_t &, dump_flags_t, gimple *, int);
592 : extern void dump_symtab_node (const dump_metadata_t &, symtab_node *);
593 :
594 : template<unsigned int N, typename C>
595 : void dump_dec (const dump_metadata_t &, const poly_int<N, C> &);
596 : extern void dump_dec (dump_flags_t, const poly_wide_int &, signop);
597 : extern void dump_hex (dump_flags_t, const poly_wide_int &);
598 :
599 : extern void dumpfile_ensure_any_optinfo_are_flushed ();
600 :
601 : /* Managing nested scopes, so that dumps can express the call chain
602 : leading to a dump message. */
603 :
604 : extern unsigned int get_dump_scope_depth ();
605 : extern void dump_begin_scope (const char *name,
606 : const dump_user_location_t &user_location,
607 : const dump_impl_location_t &impl_location);
608 : extern void dump_end_scope ();
609 :
610 : /* Implementation detail of the AUTO_DUMP_SCOPE macro below.
611 :
612 : A RAII-style class intended to make it easy to emit dump
613 : information about entering and exiting a collection of nested
614 : function calls. */
615 :
616 : class auto_dump_scope
617 : {
618 : public:
619 19854100 : auto_dump_scope (const char *name,
620 : const dump_user_location_t &user_location,
621 : const dump_impl_location_t &impl_location
622 : = dump_impl_location_t ())
623 : {
624 19854100 : if (dump_enabled_p ())
625 410641 : dump_begin_scope (name, user_location, impl_location);
626 65092 : }
627 19854100 : ~auto_dump_scope ()
628 : {
629 19854100 : if (dump_enabled_p ())
630 410641 : dump_end_scope ();
631 65092 : }
632 : };
633 :
634 : /* A macro for calling:
635 : dump_begin_scope (NAME, USER_LOC);
636 : via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc,
637 : and then calling
638 : dump_end_scope ();
639 : once the object goes out of scope, thus capturing the nesting of
640 : the scopes.
641 :
642 : These scopes affect dump messages within them: dump messages at the
643 : top level implicitly default to MSG_PRIORITY_USER_FACING, whereas those
644 : in a nested scope implicitly default to MSG_PRIORITY_INTERNALS. */
645 :
646 : #define AUTO_DUMP_SCOPE(NAME, USER_LOC) \
647 : auto_dump_scope scope (NAME, USER_LOC)
648 :
649 : extern void dump_function (int phase, tree fn);
650 : extern bool enable_rtl_dump_file (void);
651 :
652 : /* In tree-dump.cc */
653 : extern void dump_node (const_tree, dump_flags_t, FILE *);
654 :
655 : /* In cfghooks.cc */
656 : extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
657 :
658 : class opt_pass;
659 :
660 : namespace gcc {
661 :
662 : /* A class for managing all of the various dump files used by the
663 : optimization passes. */
664 :
665 : class dump_manager
666 : {
667 : public:
668 :
669 : dump_manager ();
670 : ~dump_manager ();
671 :
672 : /* Register a dumpfile.
673 :
674 : TAKE_OWNERSHIP determines whether callee takes ownership of strings
675 : SUFFIX, SWTCH, and GLOB. */
676 : unsigned int
677 : dump_register (const char *suffix, const char *swtch, const char *glob,
678 : dump_kind dkind, optgroup_flags_t optgroup_flags,
679 : bool take_ownership);
680 :
681 : /* Allow languages and middle-end to register their dumps before the
682 : optimization passes. */
683 : void
684 : register_dumps ();
685 :
686 : /* Return the dump_file_info for the given phase. */
687 : struct dump_file_info *
688 : get_dump_file_info (int phase) const;
689 :
690 : struct dump_file_info *
691 : get_dump_file_info_by_switch (const char *swtch) const;
692 :
693 : /* Return the name of the dump file for the given phase.
694 : If the dump is not enabled, returns NULL. */
695 : char *
696 : get_dump_file_name (int phase, int part = -1) const;
697 :
698 : char *
699 : get_dump_file_name (struct dump_file_info *dfi, int part = -1) const;
700 :
701 : void
702 : dump_switch_p (const char *arg);
703 :
704 : /* Start a dump for PHASE. Store user-supplied dump flags in
705 : *FLAG_PTR. Return the number of streams opened. Set globals
706 : DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and
707 : set dump_flags appropriately for both pass dump stream and
708 : -fopt-info stream. */
709 : int
710 : dump_start (int phase, dump_flags_t *flag_ptr);
711 :
712 : /* Finish a tree dump for PHASE and close associated dump streams. Also
713 : reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS. */
714 : void
715 : dump_finish (int phase);
716 :
717 : FILE *
718 : dump_begin (int phase, dump_flags_t *flag_ptr, int part);
719 :
720 : /* Returns nonzero if tree dump PHASE has been initialized. */
721 : int
722 : dump_initialized_p (int phase) const;
723 :
724 : /* Returns the switch name of PHASE. */
725 : const char *
726 : dump_flag_name (int phase) const;
727 :
728 : void register_pass (opt_pass *pass);
729 :
730 : private:
731 :
732 : int
733 : dump_phase_enabled_p (int phase) const;
734 :
735 : int
736 : dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob);
737 :
738 : int
739 : dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename);
740 :
741 : int
742 : opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
743 : const char *filename);
744 :
745 : bool update_dfi_for_opt_info (dump_file_info *dfi) const;
746 :
747 : private:
748 :
749 : /* Dynamically registered dump files and switches. */
750 : int m_next_dump;
751 : struct dump_file_info *m_extra_dump_files;
752 : size_t m_extra_dump_files_in_use;
753 : size_t m_extra_dump_files_alloced;
754 :
755 : /* Stored values from -fopt-info, for handling passes created after
756 : option-parsing (by backends and by plugins). */
757 : optgroup_flags_t m_optgroup_flags;
758 : dump_flags_t m_optinfo_flags;
759 : char *m_optinfo_filename;
760 :
761 : /* Grant access to dump_enable_all. */
762 : friend bool ::enable_rtl_dump_file (void);
763 :
764 : /* Grant access to opt_info_enable_passes. */
765 : friend int ::opt_info_switch_p (const char *arg);
766 :
767 : }; // class dump_manager
768 :
769 : } // namespace gcc
770 :
771 : #endif /* GCC_DUMPFILE_H */
|
