Branch data Line data Source code
1 : : /* Definitions for the shared dumpfile.
2 : : Copyright (C) 2004-2024 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 : 2179253 : operator| (dump_flags_t lhs, dump_flags_t rhs)
213 : : {
214 : 1231457 : return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
215 : 2179253 : | (std::underlying_type<dump_flags_t>::type)rhs);
216 : : }
217 : :
218 : : inline dump_flags_t
219 : 561908890 : operator& (dump_flags_t lhs, dump_flags_t rhs)
220 : : {
221 : 561909412 : return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
222 : 487892275 : & (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 : 29239489 : operator|= (dump_flags_t &lhs, dump_flags_t rhs)
233 : : {
234 : 29239489 : lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
235 : 29218704 : | (std::underlying_type<dump_flags_t>::type)rhs);
236 : 29239489 : return lhs;
237 : : }
238 : :
239 : : inline dump_flags_t &
240 : 976 : operator&= (dump_flags_t &lhs, dump_flags_t rhs)
241 : : {
242 : 976 : lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
243 : 976 : & (std::underlying_type<dump_flags_t>::type)rhs);
244 : 976 : 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 : 99441304 : operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
288 : : {
289 : 99441304 : lhs = (optgroup_flags_t)((std::underlying_type<dump_flags_t>::type)lhs
290 : 99441304 : | (std::underlying_type<dump_flags_t>::type)rhs);
291 : 99441304 : 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 : 319852 : 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 : 22530 : from_location_t (location_t loc)
355 : : {
356 : 22530 : 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 : 49889 : profile_count get_count () const { return m_count; }
365 : 9442592 : 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 : 22530 : 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 : 1878856 : 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 : 19054368 : : m_file (file), m_line (line), m_function (function)
395 : : {}
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 : 11381806 : dump_metadata_t (dump_flags_t dump_flags,
417 : : const dump_impl_location_t &impl_location
418 : : = dump_impl_location_t ())
419 : 11381806 : : m_dump_flags (dump_flags),
420 : 10642903 : m_impl_location (impl_location)
421 : : {
422 : : }
423 : :
424 : 21637225 : 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 : 58 : dump_location_t (const dump_impl_location_t &impl_location
450 : : = dump_impl_location_t ())
451 : 58 : : m_user_location (dump_user_location_t ()),
452 : 58 : m_impl_location (impl_location)
453 : : {
454 : : }
455 : :
456 : : /* Construct from a gimple statement (using its location and hotness). */
457 : 6181310 : dump_location_t (const gimple *stmt,
458 : : const dump_impl_location_t &impl_location
459 : : = dump_impl_location_t ())
460 : 6181310 : : m_user_location (dump_user_location_t (stmt)),
461 : 6181310 : 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 : 990265 : dump_location_t (const dump_user_location_t &user_location,
476 : : const dump_impl_location_t &impl_location
477 : : = dump_impl_location_t ())
478 : 990265 : : m_user_location (user_location),
479 : 990265 : 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 : 37363 : get_user_location () const { return m_user_location; }
496 : :
497 : : const dump_impl_location_t &
498 : 50797 : get_impl_location () const { return m_impl_location; }
499 : :
500 : 50337 : location_t get_location_t () const
501 : : {
502 : 50337 : return m_user_location.get_location_t ();
503 : : }
504 : :
505 : 49889 : 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 : 322681178 : dump_enabled_p (void)
533 : : {
534 : 284228502 : 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 : 19054372 : 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 : 19054372 : if (dump_enabled_p ())
625 : 501834 : dump_begin_scope (name, user_location, impl_location);
626 : : }
627 : 19054372 : ~auto_dump_scope ()
628 : : {
629 : 19054372 : if (dump_enabled_p ())
630 : 501834 : dump_end_scope ();
631 : : }
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 */
|
