gcc/dumpfile.h

   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 *m_extra_dump_files;
 752   size_t m_extra_dump_files_in_use;
 753   size_t m_extra_dump_files_alloced;
 754
 755   /* Stored values from -fopt-info, for handling passes created after
 756      option-parsing (by backends and by plugins).  */
 757   optgroup_flags_t m_optgroup_flags;
 758   dump_flags_t m_optinfo_flags;
 759   char *m_optinfo_filename;
 760
 761   /* Grant access to dump_enable_all.  */
 762   friend bool ::enable_rtl_dump_file (void);
 763
 764   /* Grant access to opt_info_enable_passes.  */
 765   friend int ::opt_info_switch_p (const char *arg);
 766
 767 }; // class dump_manager
 768
 769 } // namespace gcc
 770
 771 #endif /* GCC_DUMPFILE_H */