1 | /* Definitions for the shared dumpfile. |
2 | Copyright (C) 2004-2023 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 | operator| (dump_flags_t lhs, dump_flags_t rhs) |
213 | { |
214 | return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs |
215 | | (std::underlying_type<dump_flags_t>::type)rhs); |
216 | } |
217 | |
218 | inline dump_flags_t |
219 | operator& (dump_flags_t lhs, dump_flags_t rhs) |
220 | { |
221 | return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs |
222 | & (std::underlying_type<dump_flags_t>::type)rhs); |
223 | } |
224 | |
225 | inline dump_flags_t |
226 | operator~ (dump_flags_t flags) |
227 | { |
228 | return (dump_flags_t)~((std::underlying_type<dump_flags_t>::type)flags); |
229 | } |
230 | |
231 | inline dump_flags_t & |
232 | operator|= (dump_flags_t &lhs, dump_flags_t rhs) |
233 | { |
234 | lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs |
235 | | (std::underlying_type<dump_flags_t>::type)rhs); |
236 | return lhs; |
237 | } |
238 | |
239 | inline dump_flags_t & |
240 | operator&= (dump_flags_t &lhs, dump_flags_t rhs) |
241 | { |
242 | lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs |
243 | & (std::underlying_type<dump_flags_t>::type)rhs); |
244 | 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 | operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs) |
288 | { |
289 | lhs = (optgroup_flags_t)((std::underlying_type<dump_flags_t>::type)lhs |
290 | | (std::underlying_type<dump_flags_t>::type)rhs); |
291 | 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 | 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 | from_location_t (location_t loc) |
355 | { |
356 | 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 | profile_count get_count () const { return m_count; } |
365 | 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 | 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 | 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 | : 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 | dump_metadata_t (dump_flags_t dump_flags, |
417 | const dump_impl_location_t &impl_location |
418 | = dump_impl_location_t ()) |
419 | : m_dump_flags (dump_flags), |
420 | m_impl_location (impl_location) |
421 | { |
422 | } |
423 | |
424 | 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 | dump_location_t (const dump_impl_location_t &impl_location |
450 | = dump_impl_location_t ()) |
451 | : m_user_location (dump_user_location_t ()), |
452 | m_impl_location (impl_location) |
453 | { |
454 | } |
455 | |
456 | /* Construct from a gimple statement (using its location and hotness). */ |
457 | dump_location_t (const gimple *stmt, |
458 | const dump_impl_location_t &impl_location |
459 | = dump_impl_location_t ()) |
460 | : m_user_location (dump_user_location_t (stmt)), |
461 | m_impl_location (impl_location) |
462 | { |
463 | } |
464 | |
465 | /* Construct from an RTL instruction (using its location and hotness). */ |
466 | dump_location_t (const rtx_insn *insn, |
467 | const dump_impl_location_t &impl_location |
468 | = dump_impl_location_t ()) |
469 | : m_user_location (dump_user_location_t (insn)), |
470 | m_impl_location (impl_location) |
471 | { |
472 | } |
473 | |
474 | /* Construct from a dump_user_location_t. */ |
475 | dump_location_t (const dump_user_location_t &user_location, |
476 | const dump_impl_location_t &impl_location |
477 | = dump_impl_location_t ()) |
478 | : m_user_location (user_location), |
479 | 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 | from_location_t (location_t loc, |
487 | const dump_impl_location_t &impl_location |
488 | = dump_impl_location_t ()) |
489 | { |
490 | return dump_location_t (dump_user_location_t::from_location_t (loc), |
491 | impl_location); |
492 | } |
493 | |
494 | const dump_user_location_t & |
495 | get_user_location () const { return m_user_location; } |
496 | |
497 | const dump_impl_location_t & |
498 | get_impl_location () const { return m_impl_location; } |
499 | |
500 | location_t get_location_t () const |
501 | { |
502 | return m_user_location.get_location_t (); |
503 | } |
504 | |
505 | 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 | dump_enabled_p (void) |
533 | { |
534 | 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 | 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 | if (dump_enabled_p ()) |
625 | dump_begin_scope (name, user_location, impl_location); |
626 | } |
627 | ~auto_dump_scope () |
628 | { |
629 | if (dump_enabled_p ()) |
630 | 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 *; |
752 | size_t ; |
753 | size_t ; |
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 */ |
772 | |