| /* Definitions for the shared dumpfile. | |
| Copyright (C) 2004-2026 Free Software Foundation, Inc. | |
| This file is part of GCC. | |
| GCC is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3, or (at your option) | |
| any later version. | |
| GCC is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GCC; see the file COPYING3. If not see | |
| <http://www.gnu.org/licenses/>. */ | |
| #ifndef GCC_DUMPFILE_H | |
| #define GCC_DUMPFILE_H 1 | |
| #include "profile-count.h" | |
| /* An attribute for annotating formatting printing functions that use | |
| the dumpfile/optinfo formatting codes. These are the pretty_printer | |
| format codes (see pretty-print.cc), with additional codes for middle-end | |
| specific entities (see dumpfile.cc). */ | |
| #if GCC_VERSION >= 9000 | |
| #define ATTRIBUTE_GCC_DUMP_PRINTF(m, n) \ | |
| __attribute__ ((__format__ (__gcc_dump_printf__, m ,n))) \ | |
| ATTRIBUTE_NONNULL(m) | |
| #else | |
| #define ATTRIBUTE_GCC_DUMP_PRINTF(m, n) ATTRIBUTE_NONNULL(m) | |
| #endif | |
| /* Different tree dump places. When you add new tree dump places, | |
| extend the DUMP_FILES array in dumpfile.cc. */ | |
| enum tree_dump_index | |
| { | |
| TDI_none, /* No dump */ | |
| TDI_cgraph, /* dump function call graph. */ | |
| TDI_inheritance, /* dump type inheritance graph. */ | |
| TDI_clones, /* dump IPA cloning decisions. */ | |
| TDI_original, /* dump each function before optimizing it */ | |
| TDI_gimple, /* dump each function after gimplifying it */ | |
| TDI_nested, /* dump each function after unnesting it */ | |
| TDI_lto_stream_out, /* dump information about lto streaming */ | |
| TDI_profile_report, /* dump information about profile quality */ | |
| TDI_lang_all, /* enable all the language dumps. */ | |
| TDI_tree_all, /* enable all the GENERIC/GIMPLE dumps. */ | |
| TDI_rtl_all, /* enable all the RTL dumps. */ | |
| TDI_ipa_all, /* enable all the IPA dumps. */ | |
| TDI_end | |
| }; | |
| /* Enum used to distinguish dump files to types. */ | |
| enum dump_kind | |
| { | |
| DK_none, | |
| DK_lang, | |
| DK_tree, | |
| DK_rtl, | |
| DK_ipa | |
| }; | |
| /* Bit masks to control dumping. Not all values are applicable to all | |
| dumps. Add new ones at the end. When you define new values, extend | |
| the DUMP_OPTIONS array in dumpfile.cc. The TDF_* flags coexist with | |
| MSG_* flags (for -fopt-info) and the bit values must be chosen to | |
| allow that. */ | |
| enum dump_flag : uint32_t | |
| { | |
| /* Value of TDF_NONE is used just for bits filtered by TDF_KIND_MASK. */ | |
| TDF_NONE = 0, | |
| /* Dump node addresses. */ | |
| TDF_ADDRESS = (1 << 0), | |
| /* Don't go wild following links. */ | |
| TDF_SLIM = (1 << 1), | |
| /* Don't unparse the function. */ | |
| TDF_RAW = (1 << 2), | |
| /* Show more detailed info about each pass. */ | |
| TDF_DETAILS = (1 << 3), | |
| /* Dump various statistics about each pass. */ | |
| TDF_STATS = (1 << 4), | |
| /* Display basic block boundaries. */ | |
| TDF_BLOCKS = (1 << 5), | |
| /* Display virtual operands. */ | |
| TDF_VOPS = (1 << 6), | |
| /* Display statement line numbers. */ | |
| TDF_LINENO = (1 << 7), | |
| /* Display decl UIDs. */ | |
| TDF_UID = (1 << 8), | |
| /* Address of stmt. */ | |
| TDF_STMTADDR = (1 << 9), | |
| /* A graph dump is being emitted. */ | |
| TDF_GRAPH = (1 << 10), | |
| /* Display memory symbols in expr. | |
| Implies TDF_VOPS. */ | |
| TDF_MEMSYMS = (1 << 11), | |
| /* A flag to only print the RHS of a gimple stmt. */ | |
| TDF_RHS_ONLY = (1 << 12), | |
| /* Display asm names of decls. */ | |
| TDF_ASMNAME = (1 << 13), | |
| /* Display EH region number holding this gimple statement. */ | |
| TDF_EH = (1 << 14), | |
| /* Omit UIDs from dumps. */ | |
| TDF_NOUID = (1 << 15), | |
| /* Display alias information. */ | |
| TDF_ALIAS = (1 << 16), | |
| /* Enumerate locals by uid. */ | |
| TDF_ENUMERATE_LOCALS = (1 << 17), | |
| /* Dump cselib details. */ | |
| TDF_CSELIB = (1 << 18), | |
| /* Dump SCEV details. */ | |
| TDF_SCEV = (1 << 19), | |
| /* Dump in GIMPLE FE syntax. */ | |
| TDF_GIMPLE = (1 << 20), | |
| /* Dump folding details. */ | |
| TDF_FOLDING = (1 << 21), | |
| /* MSG_* flags for expressing the kinds of message to | |
| be emitted by -fopt-info. */ | |
| /* -fopt-info optimized sources. */ | |
| MSG_OPTIMIZED_LOCATIONS = (1 << 22), | |
| /* Missed opportunities. */ | |
| MSG_MISSED_OPTIMIZATION = (1 << 23), | |
| /* General optimization info. */ | |
| MSG_NOTE = (1 << 24), | |
| /* Mask for selecting MSG_-kind flags. */ | |
| MSG_ALL_KINDS = (MSG_OPTIMIZED_LOCATIONS | |
| | MSG_MISSED_OPTIMIZATION | |
| | MSG_NOTE), | |
| /* MSG_PRIORITY_* flags for expressing the priority levels of message | |
| to be emitted by -fopt-info, and filtering on them. | |
| By default, messages at the top-level dump scope are "user-facing", | |
| whereas those that are in nested scopes are implicitly "internals". | |
| This behavior can be overridden for a given dump message by explicitly | |
| specifying one of the MSG_PRIORITY_* flags. | |
| By default, dump files show both kinds of message, whereas -fopt-info | |
| only shows "user-facing" messages, and requires the "-internals" | |
| sub-option of -fopt-info to show the internal messages. */ | |
| /* Implicitly supplied for messages at the top-level dump scope. */ | |
| MSG_PRIORITY_USER_FACING = (1 << 25), | |
| /* Implicitly supplied for messages within nested dump scopes. */ | |
| MSG_PRIORITY_INTERNALS = (1 << 26), | |
| /* Supplied when an opt_problem generated in a nested scope is re-emitted | |
| at the top-level. We want to default to showing these in -fopt-info | |
| output, but to *not* show them in dump files, as the message would be | |
| shown twice, messing up "scan-tree-dump-times" in DejaGnu tests. */ | |
| MSG_PRIORITY_REEMITTED = (1 << 27), | |
| /* Mask for selecting MSG_PRIORITY_* flags. */ | |
| MSG_ALL_PRIORITIES = (MSG_PRIORITY_USER_FACING | |
| | MSG_PRIORITY_INTERNALS | |
| | MSG_PRIORITY_REEMITTED), | |
| /* All -fdump- flags. */ | |
| TDF_ALL_VALUES = (1 << 28) - 1, | |
| /* Dumping for -fcompare-debug. */ | |
| TDF_COMPARE_DEBUG = (1 << 28), | |
| /* Dump a GIMPLE value which means wrapping certain things with _Literal. */ | |
| TDF_GIMPLE_VAL = (1 << 29), | |
| /* For error. */ | |
| TDF_ERROR = ((uint32_t)1 << 30), | |
| }; | |
| /* Dump flags type. */ | |
| typedef enum dump_flag dump_flags_t; | |
| inline dump_flags_t | |
| operator| (dump_flags_t lhs, dump_flags_t rhs) | |
| { | |
| return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs | |
| | (std::underlying_type<dump_flags_t>::type)rhs); | |
| } | |
| inline dump_flags_t | |
| operator& (dump_flags_t lhs, dump_flags_t rhs) | |
| { | |
| return (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs | |
| & (std::underlying_type<dump_flags_t>::type)rhs); | |
| } | |
| inline dump_flags_t | |
| operator~ (dump_flags_t flags) | |
| { | |
| return (dump_flags_t)~((std::underlying_type<dump_flags_t>::type)flags); | |
| } | |
| inline dump_flags_t & | |
| operator|= (dump_flags_t &lhs, dump_flags_t rhs) | |
| { | |
| lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs | |
| | (std::underlying_type<dump_flags_t>::type)rhs); | |
| return lhs; | |
| } | |
| inline dump_flags_t & | |
| operator&= (dump_flags_t &lhs, dump_flags_t rhs) | |
| { | |
| lhs = (dump_flags_t)((std::underlying_type<dump_flags_t>::type)lhs | |
| & (std::underlying_type<dump_flags_t>::type)rhs); | |
| return lhs; | |
| } | |
| /* Flags to control high-level -fopt-info dumps. Usually these flags | |
| define a group of passes. An optimization pass can be part of | |
| multiple groups. */ | |
| enum optgroup_flag | |
| { | |
| OPTGROUP_NONE = 0, | |
| /* IPA optimization passes */ | |
| OPTGROUP_IPA = (1 << 1), | |
| /* Loop optimization passes */ | |
| OPTGROUP_LOOP = (1 << 2), | |
| /* Inlining passes */ | |
| OPTGROUP_INLINE = (1 << 3), | |
| /* OMP (Offloading and Multi Processing) transformations */ | |
| OPTGROUP_OMP = (1 << 4), | |
| /* Vectorization passes */ | |
| OPTGROUP_VEC = (1 << 5), | |
| /* All other passes */ | |
| OPTGROUP_OTHER = (1 << 6), | |
| OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE | |
| | OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER) | |
| }; | |
| typedef enum optgroup_flag optgroup_flags_t; | |
| inline optgroup_flags_t | |
| operator| (optgroup_flags_t lhs, optgroup_flags_t rhs) | |
| { | |
| return (optgroup_flags_t)((std::underlying_type<dump_flags_t>::type)lhs | |
| | (std::underlying_type<dump_flags_t>::type)rhs); | |
| } | |
| inline optgroup_flags_t & | |
| operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs) | |
| { | |
| lhs = (optgroup_flags_t)((std::underlying_type<dump_flags_t>::type)lhs | |
| | (std::underlying_type<dump_flags_t>::type)rhs); | |
| return lhs; | |
| } | |
| /* Define a tree dump switch. */ | |
| struct dump_file_info | |
| { | |
| /* Suffix to give output file. */ | |
| const char *suffix; | |
| /* Command line dump switch. */ | |
| const char *swtch; | |
| /* Command line glob. */ | |
| const char *glob; | |
| /* Filename for the pass-specific stream. */ | |
| const char *pfilename; | |
| /* Filename for the -fopt-info stream. */ | |
| const char *alt_filename; | |
| /* Pass-specific dump stream. */ | |
| FILE *pstream; | |
| /* -fopt-info stream. */ | |
| FILE *alt_stream; | |
| /* Dump kind. */ | |
| dump_kind dkind; | |
| /* Dump flags. */ | |
| dump_flags_t pflags; | |
| /* A pass flags for -fopt-info. */ | |
| dump_flags_t alt_flags; | |
| /* Flags for -fopt-info given by a user. */ | |
| optgroup_flags_t optgroup_flags; | |
| /* State of pass-specific stream. */ | |
| int pstate; | |
| /* State of the -fopt-info stream. */ | |
| int alt_state; | |
| /* Dump file number. */ | |
| int num; | |
| /* Fields "suffix", "swtch", "glob" can be const strings, | |
| or can be dynamically allocated, needing free. */ | |
| bool owns_strings; | |
| /* When a given dump file is being initialized, this flag is set to true | |
| if the corresponding TDF_graph dump file has also been initialized. */ | |
| bool graph_dump_initialized; | |
| }; | |
| /* A class for describing where in the user's source that a dump message | |
| relates to, with various constructors for convenience. | |
| In particular, this lets us associate dump messages | |
| with hotness information (e.g. from PGO), allowing them to | |
| be prioritized by code hotness. */ | |
| class dump_user_location_t | |
| { | |
| public: | |
| /* Default constructor, analogous to UNKNOWN_LOCATION. */ | |
| dump_user_location_t () : m_count (), m_loc (UNKNOWN_LOCATION) {} | |
| /* Construct from a gimple statement (using its location and hotness). */ | |
| dump_user_location_t (const gimple *stmt); | |
| /* Construct from an RTL instruction (using its location and hotness). */ | |
| dump_user_location_t (const rtx_insn *insn); | |
| /* Construct from a location_t. This one is deprecated (since it doesn't | |
| capture hotness information); it thus needs to be spelled out. */ | |
| static dump_user_location_t | |
| from_location_t (location_t loc) | |
| { | |
| return dump_user_location_t (profile_count (), loc); | |
| } | |
| /* Construct from a function declaration. This one requires spelling out | |
| to avoid accidentally constructing from other kinds of tree. */ | |
| static dump_user_location_t | |
| from_function_decl (tree fndecl); | |
| profile_count get_count () const { return m_count; } | |
| location_t get_location_t () const { return m_loc; } | |
| private: | |
| /* Private ctor from count and location, for use by from_location_t. */ | |
| dump_user_location_t (profile_count count, location_t loc) | |
| : m_count (count), m_loc (loc) | |
| {} | |
| profile_count m_count; | |
| location_t m_loc; | |
| }; | |
| /* A class for identifying where in the compiler's own source | |
| (or a plugin) that a dump message is being emitted from. */ | |
| class dump_impl_location_t | |
| { | |
| public: | |
| dump_impl_location_t ( | |
| #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) | |
| const char *file = __builtin_FILE (), | |
| int line = __builtin_LINE (), | |
| const char *function = __builtin_FUNCTION () | |
| #else | |
| const char *file = __FILE__, | |
| int line = __LINE__, | |
| const char *function = NULL | |
| #endif | |
| ) | |
| : m_file (file), m_line (line), m_function (function) | |
| {} | |
| const char *m_file; | |
| int m_line; | |
| const char *m_function; | |
| }; | |
| /* A bundle of metadata for describing a dump message: | |
| (a) the dump_flags | |
| (b) the source location within the compiler/plugin. | |
| The constructors use default parameters so that (b) gets sets up | |
| automatically. | |
| Hence you can pass in e.g. MSG_NOTE, and the dump call | |
| will automatically record where in GCC's source code the | |
| dump was emitted from. */ | |
| class dump_metadata_t | |
| { | |
| public: | |
| dump_metadata_t (dump_flags_t dump_flags, | |
| const dump_impl_location_t &impl_location | |
| = dump_impl_location_t ()) | |
| : m_dump_flags (dump_flags), | |
| m_impl_location (impl_location) | |
| { | |
| } | |
| dump_flags_t get_dump_flags () const { return m_dump_flags; } | |
| const dump_impl_location_t & | |
| get_impl_location () const { return m_impl_location; } | |
| private: | |
| dump_flags_t m_dump_flags; | |
| dump_impl_location_t m_impl_location; | |
| }; | |
| /* A bundle of information for describing the location of a dump message: | |
| (a) the source location and hotness within the user's code, together with | |
| (b) the source location within the compiler/plugin. | |
| The constructors use default parameters so that (b) gets sets up | |
| automatically. | |
| The upshot is that you can pass in e.g. a gimple * to dump_printf_loc, | |
| and the dump call will automatically record where in GCC's source | |
| code the dump was emitted from. */ | |
| class dump_location_t | |
| { | |
| public: | |
| /* Default constructor, analogous to UNKNOWN_LOCATION. */ | |
| dump_location_t (const dump_impl_location_t &impl_location | |
| = dump_impl_location_t ()) | |
| : m_user_location (dump_user_location_t ()), | |
| m_impl_location (impl_location) | |
| { | |
| } | |
| /* Construct from a gimple statement (using its location and hotness). */ | |
| dump_location_t (const gimple *stmt, | |
| const dump_impl_location_t &impl_location | |
| = dump_impl_location_t ()) | |
| : m_user_location (dump_user_location_t (stmt)), | |
| m_impl_location (impl_location) | |
| { | |
| } | |
| /* Construct from an RTL instruction (using its location and hotness). */ | |
| dump_location_t (const rtx_insn *insn, | |
| const dump_impl_location_t &impl_location | |
| = dump_impl_location_t ()) | |
| : m_user_location (dump_user_location_t (insn)), | |
| m_impl_location (impl_location) | |
| { | |
| } | |
| /* Construct from a dump_user_location_t. */ | |
| dump_location_t (const dump_user_location_t &user_location, | |
| const dump_impl_location_t &impl_location | |
| = dump_impl_location_t ()) | |
| : m_user_location (user_location), | |
| m_impl_location (impl_location) | |
| { | |
| } | |
| /* Construct from a location_t. This one is deprecated (since it doesn't | |
| capture hotness information), and thus requires spelling out. */ | |
| static dump_location_t | |
| from_location_t (location_t loc, | |
| const dump_impl_location_t &impl_location | |
| = dump_impl_location_t ()) | |
| { | |
| return dump_location_t (dump_user_location_t::from_location_t (loc), | |
| impl_location); | |
| } | |
| const dump_user_location_t & | |
| get_user_location () const { return m_user_location; } | |
| const dump_impl_location_t & | |
| get_impl_location () const { return m_impl_location; } | |
| location_t get_location_t () const | |
| { | |
| return m_user_location.get_location_t (); | |
| } | |
| profile_count get_count () const { return m_user_location.get_count (); } | |
| private: | |
| dump_user_location_t m_user_location; | |
| dump_impl_location_t m_impl_location; | |
| }; | |
| /* In dumpfile.cc */ | |
| extern FILE *dump_begin (int, dump_flags_t *, int part=-1); | |
| extern void dump_end (int, FILE *); | |
| extern int opt_info_switch_p (const char *); | |
| extern const char *dump_flag_name (int); | |
| extern const kv_pair<optgroup_flags_t> optgroup_options[]; | |
| extern dump_flags_t | |
| parse_dump_option (const char *, const char **); | |
| /* Global variables used to communicate with passes. */ | |
| extern FILE *dump_file; | |
| extern dump_flags_t dump_flags; | |
| extern const char *dump_file_name; | |
| extern bool dumps_are_enabled; | |
| extern void set_dump_file (FILE *new_dump_file); | |
| /* Return true if any of the dumps is enabled, false otherwise. */ | |
| inline bool | |
| dump_enabled_p (void) | |
| { | |
| return dumps_are_enabled; | |
| } | |
| /* The following API calls (which *don't* take a "FILE *") | |
| write the output to zero or more locations. | |
| Some destinations are written to immediately as dump_* calls | |
| are made; for others, the output is consolidated into an "optinfo" | |
| instance (with its own metadata), and only emitted once the optinfo | |
| is complete. | |
| The destinations are: | |
| (a) the "immediate" destinations: | |
| (a.1) the active dump_file, if any | |
| (a.2) the -fopt-info destination, if any | |
| (b) the "optinfo" destinations, if any: | |
| (b.1) as optimization records | |
| dump_* (MSG_*) --> dumpfile.cc --> items --> (a.1) dump_file | |
| | `-> (a.2) alt_dump_file | |
| | | |
| `--> (b) optinfo | |
| `---> optinfo destinations | |
| (b.1) optimization records | |
| For optinfos, the dump_*_loc mark the beginning of an optinfo | |
| instance: all subsequent dump_* calls are consolidated into | |
| that optinfo, until the next dump_*_loc call (or a change in | |
| dump scope, or a call to dumpfile_ensure_any_optinfo_are_flushed). | |
| A group of dump_* calls should be guarded by: | |
| if (dump_enabled_p ()) | |
| to minimize the work done for the common case where dumps | |
| are disabled. */ | |
| extern void dump_printf (const dump_metadata_t &, const char *, ...) | |
| ATTRIBUTE_GCC_DUMP_PRINTF (2, 3); | |
| extern void dump_printf_loc (const dump_metadata_t &, const dump_user_location_t &, | |
| const char *, ...) | |
| ATTRIBUTE_GCC_DUMP_PRINTF (3, 4); | |
| extern void dump_function (int phase, tree fn); | |
| extern void dump_basic_block (dump_flags_t, basic_block, int); | |
| extern void dump_generic_expr_loc (const dump_metadata_t &, | |
| const dump_user_location_t &, | |
| dump_flags_t, tree); | |
| extern void dump_generic_expr (const dump_metadata_t &, dump_flags_t, tree); | |
| extern void dump_gimple_stmt_loc (const dump_metadata_t &, | |
| const dump_user_location_t &, | |
| dump_flags_t, gimple *, int); | |
| extern void dump_gimple_stmt (const dump_metadata_t &, dump_flags_t, gimple *, int); | |
| extern void dump_gimple_expr_loc (const dump_metadata_t &, | |
| const dump_user_location_t &, | |
| dump_flags_t, gimple *, int); | |
| extern void dump_gimple_expr (const dump_metadata_t &, dump_flags_t, gimple *, int); | |
| extern void dump_symtab_node (const dump_metadata_t &, symtab_node *); | |
| template<unsigned int N, typename C> | |
| void dump_dec (const dump_metadata_t &, const poly_int<N, C> &); | |
| extern void dump_dec (dump_flags_t, const poly_wide_int &, signop); | |
| extern void dump_hex (dump_flags_t, const poly_wide_int &); | |
| extern void dumpfile_ensure_any_optinfo_are_flushed (); | |
| /* Managing nested scopes, so that dumps can express the call chain | |
| leading to a dump message. */ | |
| extern unsigned int get_dump_scope_depth (); | |
| extern void dump_begin_scope (const char *name, | |
| const dump_user_location_t &user_location, | |
| const dump_impl_location_t &impl_location); | |
| extern void dump_end_scope (); | |
| /* Implementation detail of the AUTO_DUMP_SCOPE macro below. | |
| A RAII-style class intended to make it easy to emit dump | |
| information about entering and exiting a collection of nested | |
| function calls. */ | |
| class auto_dump_scope | |
| { | |
| public: | |
| auto_dump_scope (const char *name, | |
| const dump_user_location_t &user_location, | |
| const dump_impl_location_t &impl_location | |
| = dump_impl_location_t ()) | |
| { | |
| if (dump_enabled_p ()) | |
| dump_begin_scope (name, user_location, impl_location); | |
| } | |
| ~auto_dump_scope () | |
| { | |
| if (dump_enabled_p ()) | |
| dump_end_scope (); | |
| } | |
| }; | |
| /* A macro for calling: | |
| dump_begin_scope (NAME, USER_LOC); | |
| via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc, | |
| and then calling | |
| dump_end_scope (); | |
| once the object goes out of scope, thus capturing the nesting of | |
| the scopes. | |
| These scopes affect dump messages within them: dump messages at the | |
| top level implicitly default to MSG_PRIORITY_USER_FACING, whereas those | |
| in a nested scope implicitly default to MSG_PRIORITY_INTERNALS. */ | |
| #define AUTO_DUMP_SCOPE(NAME, USER_LOC) \ | |
| auto_dump_scope scope (NAME, USER_LOC) | |
| extern void dump_function (int phase, tree fn); | |
| extern bool enable_rtl_dump_file (void); | |
| /* In tree-dump.cc */ | |
| extern void dump_node (const_tree, dump_flags_t, FILE *); | |
| /* In cfghooks.cc */ | |
| extern void dump_bb (FILE *, basic_block, int, dump_flags_t); | |
| class opt_pass; | |
| namespace gcc { | |
| /* A class for managing all of the various dump files used by the | |
| optimization passes. */ | |
| class dump_manager | |
| { | |
| public: | |
| dump_manager (); | |
| ~dump_manager (); | |
| /* Register a dumpfile. | |
| TAKE_OWNERSHIP determines whether callee takes ownership of strings | |
| SUFFIX, SWTCH, and GLOB. */ | |
| unsigned int | |
| dump_register (const char *suffix, const char *swtch, const char *glob, | |
| dump_kind dkind, optgroup_flags_t optgroup_flags, | |
| bool take_ownership); | |
| /* Allow languages and middle-end to register their dumps before the | |
| optimization passes. */ | |
| void | |
| register_dumps (); | |
| /* Return the dump_file_info for the given phase. */ | |
| struct dump_file_info * | |
| get_dump_file_info (int phase) const; | |
| struct dump_file_info * | |
| get_dump_file_info_by_switch (const char *swtch) const; | |
| /* Return the name of the dump file for the given phase. | |
| If the dump is not enabled, returns NULL. */ | |
| char * | |
| get_dump_file_name (int phase, int part = -1) const; | |
| char * | |
| get_dump_file_name (struct dump_file_info *dfi, int part = -1) const; | |
| void | |
| dump_switch_p (const char *arg); | |
| /* Start a dump for PHASE. Store user-supplied dump flags in | |
| *FLAG_PTR. Return the number of streams opened. Set globals | |
| DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and | |
| set dump_flags appropriately for both pass dump stream and | |
| -fopt-info stream. */ | |
| int | |
| dump_start (int phase, dump_flags_t *flag_ptr); | |
| /* Finish a tree dump for PHASE and close associated dump streams. Also | |
| reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS. */ | |
| void | |
| dump_finish (int phase); | |
| FILE * | |
| dump_begin (int phase, dump_flags_t *flag_ptr, int part); | |
| /* Returns nonzero if tree dump PHASE has been initialized. */ | |
| int | |
| dump_initialized_p (int phase) const; | |
| /* Returns the switch name of PHASE. */ | |
| const char * | |
| dump_flag_name (int phase) const; | |
| void register_pass (opt_pass *pass); | |
| private: | |
| int | |
| dump_phase_enabled_p (int phase) const; | |
| int | |
| dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob); | |
| int | |
| dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename); | |
| int | |
| opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags, | |
| const char *filename); | |
| bool update_dfi_for_opt_info (dump_file_info *dfi) const; | |
| private: | |
| /* Dynamically registered dump files and switches. */ | |
| int m_next_dump; | |
| struct dump_file_info *m_extra_dump_files; | |
| size_t m_extra_dump_files_in_use; | |
| size_t m_extra_dump_files_alloced; | |
| /* Stored values from -fopt-info, for handling passes created after | |
| option-parsing (by backends and by plugins). */ | |
| optgroup_flags_t m_optgroup_flags; | |
| dump_flags_t m_optinfo_flags; | |
| char *m_optinfo_filename; | |
| /* Grant access to dump_enable_all. */ | |
| friend bool ::enable_rtl_dump_file (void); | |
| /* Grant access to opt_info_enable_passes. */ | |
| friend int ::opt_info_switch_p (const char *arg); | |
| }; // class dump_manager | |
| } // namespace gcc | |
| #endif /* GCC_DUMPFILE_H */ |