/* Definitions for the shared dumpfile.
- Copyright (C) 2004-2013 Free Software Foundation, Inc.
+ Copyright (C) 2004-2020 Free Software Foundation, Inc.
This file is part of GCC.
#ifndef GCC_DUMPFILE_H
#define GCC_DUMPFILE_H 1
-#include "line-map.h"
+#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.c), with additional codes for middle-end
+ specific entities (see dumpfile.c). */
+
+#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.c. */
enum tree_dump_index
{
TDI_none, /* No dump */
- TDI_cgraph, /* dump function call graph. */
- TDI_tu, /* dump the whole translation unit. */
- TDI_class, /* dump class hierarchy. */
+ 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_generic, /* dump each function after genericizing it */
+ TDI_gimple, /* dump each function after gimplifying it */
TDI_nested, /* dump each function after unnesting it */
- 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_lto_stream_out, /* dump information about lto streaming */
+
+ 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.c. The TDF_* flags coexist with
MSG_* flags (for -fopt-info) and the bit values must be chosen to
allow that. */
-#define TDF_ADDRESS (1 << 0) /* dump node addresses */
-#define TDF_SLIM (1 << 1) /* don't go wild following links */
-#define TDF_RAW (1 << 2) /* don't unparse the function */
-#define TDF_DETAILS (1 << 3) /* show more detailed info about
- each pass */
-#define TDF_STATS (1 << 4) /* dump various statistics about
- each pass */
-#define TDF_BLOCKS (1 << 5) /* display basic block boundaries */
-#define TDF_VOPS (1 << 6) /* display virtual operands */
-#define TDF_LINENO (1 << 7) /* display statement line numbers */
-#define TDF_UID (1 << 8) /* display decl UIDs */
-
-#define TDF_TREE (1 << 9) /* is a tree dump */
-#define TDF_RTL (1 << 10) /* is a RTL dump */
-#define TDF_IPA (1 << 11) /* is an IPA dump */
-#define TDF_STMTADDR (1 << 12) /* Address of stmt. */
-
-#define TDF_GRAPH (1 << 13) /* a graph dump is being emitted */
-#define TDF_MEMSYMS (1 << 14) /* display memory symbols in expr.
- Implies TDF_VOPS. */
-
-#define TDF_DIAGNOSTIC (1 << 15) /* A dump to be put in a diagnostic
- message. */
-#define TDF_VERBOSE (1 << 16) /* A dump that uses the full tree
- dumper to print stmts. */
-#define TDF_RHS_ONLY (1 << 17) /* a flag to only print the RHS of
- a gimple stmt. */
-#define TDF_ASMNAME (1 << 18) /* display asm names of decls */
-#define TDF_EH (1 << 19) /* display EH region number
- holding this gimple statement. */
-#define TDF_NOUID (1 << 20) /* omit UIDs from dumps. */
-#define TDF_ALIAS (1 << 21) /* display alias information */
-#define TDF_ENUMERATE_LOCALS (1 << 22) /* Enumerate locals by uid. */
-#define TDF_CSELIB (1 << 23) /* Dump cselib details. */
-#define TDF_SCEV (1 << 24) /* Dump SCEV details. */
-#define TDF_COMMENT (1 << 25) /* Dump lines with prefix ";;" */
-#define MSG_OPTIMIZED_LOCATIONS (1 << 26) /* -fopt-info optimized sources */
-#define MSG_MISSED_OPTIMIZATION (1 << 27) /* missed opportunities */
-#define MSG_NOTE (1 << 28) /* general optimization info */
-#define MSG_ALL (MSG_OPTIMIZED_LOCATIONS | MSG_MISSED_OPTIMIZATION \
- | MSG_NOTE)
+enum dump_flag
+{
+ /* 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),
+
+ /* Dumping for -fcompare-debug. */
+ TDF_COMPARE_DEBUG = (1 << 28),
+
+ /* For error. */
+ TDF_ERROR = (1 << 26),
+
+ /* All values. */
+ TDF_ALL_VALUES = (1 << 29) - 1
+};
+
+/* Dump flags type. */
+
+typedef enum dump_flag dump_flags_t;
+
+static inline dump_flags_t
+operator| (dump_flags_t lhs, dump_flags_t rhs)
+{
+ return (dump_flags_t)((int)lhs | (int)rhs);
+}
+
+static inline dump_flags_t
+operator& (dump_flags_t lhs, dump_flags_t rhs)
+{
+ return (dump_flags_t)((int)lhs & (int)rhs);
+}
+
+static inline dump_flags_t
+operator~ (dump_flags_t flags)
+{
+ return (dump_flags_t)~((int)flags);
+}
+
+static inline dump_flags_t &
+operator|= (dump_flags_t &lhs, dump_flags_t rhs)
+{
+ lhs = (dump_flags_t)((int)lhs | (int)rhs);
+ return lhs;
+}
+
+static inline dump_flags_t &
+operator&= (dump_flags_t &lhs, dump_flags_t rhs)
+{
+ lhs = (dump_flags_t)((int)lhs & (int)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. */
-#define OPTGROUP_NONE (0)
-#define OPTGROUP_IPA (1 << 1) /* IPA optimization passes */
-#define OPTGROUP_LOOP (1 << 2) /* Loop optimization passes */
-#define OPTGROUP_INLINE (1 << 3) /* Inlining passes */
-#define OPTGROUP_VEC (1 << 4) /* Vectorization passes */
-#define OPTGROUP_ALL (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE \
- | OPTGROUP_VEC)
+
+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;
+
+static inline optgroup_flags_t
+operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
+{
+ return (optgroup_flags_t)((int)lhs | (int)rhs);
+}
+
+static inline optgroup_flags_t &
+operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
+{
+ lhs = (optgroup_flags_t)((int)lhs | (int)rhs);
+ return lhs;
+}
/* Define a tree dump switch. */
struct dump_file_info
{
- const char *suffix; /* suffix to give output file. */
- const char *swtch; /* command line dump switch */
- const char *glob; /* command line glob */
- const char *pfilename; /* filename for the pass-specific stream */
- const char *alt_filename; /* filename for the -fopt-info stream */
- FILE *pstream; /* pass-specific dump stream */
- FILE *alt_stream; /* -fopt-info stream */
- int pflags; /* dump flags */
- int optgroup_flags; /* optgroup flags for -fopt-info */
- int alt_flags; /* flags for opt-info */
- int pstate; /* state of pass-specific stream */
- int alt_state; /* state of the -fopt-info stream */
- int num; /* dump file number */
+ /* 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.c */
-extern char *get_dump_file_name (int);
-extern int dump_initialized_p (int);
-extern FILE *dump_begin (int, int *);
+extern FILE *dump_begin (int, dump_flags_t *, int part=-1);
extern void dump_end (int, FILE *);
-extern int dump_start (int, int *);
-extern void dump_finish (int);
-extern void dump_node (const_tree, int, FILE *);
-extern int dump_switch_p (const char *);
extern int opt_info_switch_p (const char *);
extern const char *dump_flag_name (int);
-extern void dump_printf (int, const char *, ...) ATTRIBUTE_PRINTF_2;
-extern void dump_printf_loc (int, source_location,
- const char *, ...) ATTRIBUTE_PRINTF_3;
-extern void dump_basic_block (int, basic_block, int);
-extern void dump_generic_expr_loc (int, source_location, int, tree);
-extern void dump_generic_expr (int, int, tree);
-extern void dump_gimple_stmt_loc (int, source_location, int, gimple, int);
-extern void dump_gimple_stmt (int, int, gimple, int);
-extern void print_combine_total_stats (void);
-extern unsigned int dump_register (const char *, const char *, const char *,
- int, int);
-extern bool enable_rtl_dump_file (void);
-
-/* In combine.c */
-extern void dump_combine_total_stats (FILE *);
-/* In cfghooks.c */
-extern void dump_bb (FILE *, basic_block, int, 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 FILE *alt_dump_file;
-extern int dump_flags;
+extern dump_flags_t dump_flags;
extern const char *dump_file_name;
-/* Return the dump_file_info for the given phase. */
-extern struct dump_file_info *get_dump_file_info (int);
+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. */
static inline bool
dump_enabled_p (void)
{
- return (dump_file || alt_dump_file);
+ 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.c --> 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, 0);
+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 void print_combine_total_stats (void);
+extern bool enable_rtl_dump_file (void);
+
+/* In tree-dump.c */
+extern void dump_node (const_tree, dump_flags_t, FILE *);
+
+/* In combine.c */
+extern void dump_combine_total_stats (FILE *);
+/* In cfghooks.c */
+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 */
projects / thirdparty / gcc.git / blobdiff