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