gcc/dumpfile.h

   1 /* Definitions for the shared dumpfile.
   2    Copyright (C) 2004-2021 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.c), with additional codes for middle-end
  29    specific entities (see dumpfile.c).  */
  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.c.  */
  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.c. 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
  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   /* Dumping for -fcompare-debug.  */
 195   TDF_COMPARE_DEBUG = (1 << 28),
 196
 197   /* For error.  */
 198   TDF_ERROR = (1 << 26),
 199
 200   /* Dumping for range path solver.  */
 201   TDF_THREADING = (1 << 27),
 202
 203   /* All values.  */
 204   TDF_ALL_VALUES = (1 << 29) - 1
 205 };
 206
 207 /* Dump flags type.  */
 208
 209 typedef enum dump_flag dump_flags_t;
 210
 211 static inline dump_flags_t
 212 operator| (dump_flags_t lhs, dump_flags_t rhs)
 213 {
 214   return (dump_flags_t)((int)lhs | (int)rhs);
 215 }
 216
 217 static inline dump_flags_t
 218 operator& (dump_flags_t lhs, dump_flags_t rhs)
 219 {
 220   return (dump_flags_t)((int)lhs & (int)rhs);
 221 }
 222
 223 static inline dump_flags_t
 224 operator~ (dump_flags_t flags)
 225 {
 226   return (dump_flags_t)~((int)flags);
 227 }
 228
 229 static inline dump_flags_t &
 230 operator|= (dump_flags_t &lhs, dump_flags_t rhs)
 231 {
 232   lhs = (dump_flags_t)((int)lhs | (int)rhs);
 233   return lhs;
 234 }
 235
 236 static inline dump_flags_t &
 237 operator&= (dump_flags_t &lhs, dump_flags_t rhs)
 238 {
 239   lhs = (dump_flags_t)((int)lhs & (int)rhs);
 240   return lhs;
 241 }
 242
 243 /* Flags to control high-level -fopt-info dumps.  Usually these flags
 244    define a group of passes.  An optimization pass can be part of
 245    multiple groups.  */
 246
 247 enum optgroup_flag
 248 {
 249   OPTGROUP_NONE = 0,
 250
 251   /* IPA optimization passes */
 252   OPTGROUP_IPA  = (1 << 1),
 253
 254   /* Loop optimization passes */
 255   OPTGROUP_LOOP = (1 << 2),
 256
 257   /* Inlining passes */
 258   OPTGROUP_INLINE = (1 << 3),
 259
 260   /* OMP (Offloading and Multi Processing) transformations */
 261   OPTGROUP_OMP = (1 << 4),
 262
 263   /* Vectorization passes */
 264   OPTGROUP_VEC = (1 << 5),
 265
 266   /* All other passes */
 267   OPTGROUP_OTHER = (1 << 6),
 268
 269   OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE
 270                   | OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
 271 };
 272
 273 typedef enum optgroup_flag optgroup_flags_t;
 274
 275 static inline optgroup_flags_t
 276 operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
 277 {
 278   return (optgroup_flags_t)((int)lhs | (int)rhs);
 279 }
 280
 281 static inline optgroup_flags_t &
 282 operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
 283 {
 284   lhs = (optgroup_flags_t)((int)lhs | (int)rhs);
 285   return lhs;
 286 }
 287
 288 /* Define a tree dump switch.  */
 289 struct dump_file_info
 290 {
 291   /* Suffix to give output file.  */
 292   const char *suffix;
 293   /* Command line dump switch.  */
 294   const char *swtch;
 295   /* Command line glob.  */
 296   const char *glob;
 297   /* Filename for the pass-specific stream.  */
 298   const char *pfilename;
 299   /* Filename for the -fopt-info stream.  */
 300   const char *alt_filename;
 301   /* Pass-specific dump stream.  */
 302   FILE *pstream;
 303   /* -fopt-info stream.  */
 304   FILE *alt_stream;
 305   /* Dump kind.  */
 306   dump_kind dkind;
 307   /* Dump flags.  */
 308   dump_flags_t pflags;
 309   /* A pass flags for -fopt-info.  */
 310   dump_flags_t alt_flags;
 311   /* Flags for -fopt-info given by a user.  */
 312   optgroup_flags_t optgroup_flags;
 313   /* State of pass-specific stream.  */
 314   int pstate;
 315   /* State of the -fopt-info stream.  */
 316   int alt_state;
 317   /* Dump file number.  */
 318   int num;
 319   /* Fields "suffix", "swtch", "glob" can be const strings,
 320      or can be dynamically allocated, needing free.  */
 321   bool owns_strings;
 322   /* When a given dump file is being initialized, this flag is set to true
 323      if the corresponding TDF_graph dump file has also been initialized.  */
 324   bool graph_dump_initialized;
 325 };
 326
 327 /* A class for describing where in the user's source that a dump message
 328    relates to, with various constructors for convenience.
 329    In particular, this lets us associate dump messages
 330    with hotness information (e.g. from PGO), allowing them to
 331    be prioritized by code hotness.  */
 332
 333 class dump_user_location_t
 334 {
 335  public:
 336   /* Default constructor, analogous to UNKNOWN_LOCATION.  */
 337   dump_user_location_t () : m_count (), m_loc (UNKNOWN_LOCATION) {}
 338
 339   /* Construct from a gimple statement (using its location and hotness).  */
 340   dump_user_location_t (const gimple *stmt);
 341
 342   /* Construct from an RTL instruction (using its location and hotness).  */
 343   dump_user_location_t (const rtx_insn *insn);
 344
 345   /* Construct from a location_t.  This one is deprecated (since it doesn't
 346      capture hotness information); it thus needs to be spelled out.  */
 347   static dump_user_location_t
 348   from_location_t (location_t loc)
 349   {
 350     return dump_user_location_t (profile_count (), loc);
 351   }
 352
 353   /* Construct from a function declaration.  This one requires spelling out
 354      to avoid accidentally constructing from other kinds of tree.  */
 355   static dump_user_location_t
 356   from_function_decl (tree fndecl);
 357
 358   profile_count get_count () const { return m_count; }
 359   location_t get_location_t () const { return m_loc; }
 360
 361  private:
 362   /* Private ctor from count and location, for use by from_location_t.  */
 363   dump_user_location_t (profile_count count, location_t loc)
 364     : m_count (count), m_loc (loc)
 365   {}
 366
 367   profile_count m_count;
 368   location_t m_loc;
 369 };
 370
 371 /* A class for identifying where in the compiler's own source
 372    (or a plugin) that a dump message is being emitted from.  */
 373
 374 class dump_impl_location_t
 375 {
 376 public:
 377   dump_impl_location_t (
 378 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 379                         const char *file = __builtin_FILE (),
 380                         int line = __builtin_LINE (),
 381                         const char *function = __builtin_FUNCTION ()
 382 #else
 383                         const char *file = __FILE__,
 384                         int line = __LINE__,
 385                         const char *function = NULL
 386 #endif
 387   )
 388   : m_file (file), m_line (line), m_function (function)
 389   {}
 390
 391   const char *m_file;
 392   int m_line;
 393   const char *m_function;
 394 };
 395
 396 /* A bundle of metadata for describing a dump message:
 397    (a) the dump_flags
 398    (b) the source location within the compiler/plugin.
 399
 400    The constructors use default parameters so that (b) gets sets up
 401    automatically.
 402
 403    Hence you can pass in e.g. MSG_NOTE, and the dump call
 404    will automatically record where in GCC's source code the
 405    dump was emitted from.  */
 406
 407 class dump_metadata_t
 408 {
 409  public:
 410   dump_metadata_t (dump_flags_t dump_flags,
 411                    const dump_impl_location_t &impl_location
 412                      = dump_impl_location_t ())
 413   : m_dump_flags (dump_flags),
 414     m_impl_location (impl_location)
 415   {
 416   }
 417
 418   dump_flags_t get_dump_flags () const { return m_dump_flags; }
 419
 420   const dump_impl_location_t &
 421   get_impl_location () const { return m_impl_location; }
 422
 423  private:
 424   dump_flags_t m_dump_flags;
 425   dump_impl_location_t m_impl_location;
 426 };
 427
 428 /* A bundle of information for describing the location of a dump message:
 429    (a) the source location and hotness within the user's code, together with
 430    (b) the source location within the compiler/plugin.
 431
 432    The constructors use default parameters so that (b) gets sets up
 433    automatically.
 434
 435    The upshot is that you can pass in e.g. a gimple * to dump_printf_loc,
 436    and the dump call will automatically record where in GCC's source
 437    code the dump was emitted from.  */
 438
 439 class dump_location_t
 440 {
 441  public:
 442   /* Default constructor, analogous to UNKNOWN_LOCATION.  */
 443   dump_location_t (const dump_impl_location_t &impl_location
 444                      = dump_impl_location_t ())
 445   : m_user_location (dump_user_location_t ()),
 446     m_impl_location (impl_location)
 447   {
 448   }
 449
 450   /* Construct from a gimple statement (using its location and hotness).  */
 451   dump_location_t (const gimple *stmt,
 452                    const dump_impl_location_t &impl_location
 453                      = dump_impl_location_t ())
 454   : m_user_location (dump_user_location_t (stmt)),
 455     m_impl_location (impl_location)
 456   {
 457   }
 458
 459   /* Construct from an RTL instruction (using its location and hotness).  */
 460   dump_location_t (const rtx_insn *insn,
 461                    const dump_impl_location_t &impl_location
 462                    = dump_impl_location_t ())
 463   : m_user_location (dump_user_location_t (insn)),
 464     m_impl_location (impl_location)
 465   {
 466   }
 467
 468   /* Construct from a dump_user_location_t.  */
 469   dump_location_t (const dump_user_location_t &user_location,
 470                    const dump_impl_location_t &impl_location
 471                      = dump_impl_location_t ())
 472   : m_user_location (user_location),
 473     m_impl_location (impl_location)
 474   {
 475   }
 476
 477   /* Construct from a location_t.  This one is deprecated (since it doesn't
 478      capture hotness information), and thus requires spelling out.  */
 479   static dump_location_t
 480   from_location_t (location_t loc,
 481                    const dump_impl_location_t &impl_location
 482                      = dump_impl_location_t ())
 483   {
 484     return dump_location_t (dump_user_location_t::from_location_t (loc),
 485                             impl_location);
 486   }
 487
 488   const dump_user_location_t &
 489   get_user_location () const { return m_user_location; }
 490
 491   const dump_impl_location_t &
 492   get_impl_location () const { return m_impl_location; }
 493
 494   location_t get_location_t () const
 495   {
 496     return m_user_location.get_location_t ();
 497   }
 498
 499   profile_count get_count () const { return m_user_location.get_count (); }
 500
 501  private:
 502   dump_user_location_t m_user_location;
 503   dump_impl_location_t m_impl_location;
 504 };
 505
 506 /* In dumpfile.c */
 507 extern FILE *dump_begin (int, dump_flags_t *, int part=-1);
 508 extern void dump_end (int, FILE *);
 509 extern int opt_info_switch_p (const char *);
 510 extern const char *dump_flag_name (int);
 511 extern const kv_pair<optgroup_flags_t> optgroup_options[];
 512 extern dump_flags_t
 513 parse_dump_option (const char *, const char **);
 514
 515 /* Global variables used to communicate with passes.  */
 516 extern FILE *dump_file;
 517 extern dump_flags_t dump_flags;
 518 extern const char *dump_file_name;
 519
 520 extern bool dumps_are_enabled;
 521
 522 extern void set_dump_file (FILE *new_dump_file);
 523
 524 /* Return true if any of the dumps is enabled, false otherwise. */
 525 static inline bool
 526 dump_enabled_p (void)
 527 {
 528   return dumps_are_enabled;
 529 }
 530
 531 /* The following API calls (which *don't* take a "FILE *")
 532    write the output to zero or more locations.
 533
 534    Some destinations are written to immediately as dump_* calls
 535    are made; for others, the output is consolidated into an "optinfo"
 536    instance (with its own metadata), and only emitted once the optinfo
 537    is complete.
 538
 539    The destinations are:
 540
 541    (a) the "immediate" destinations:
 542        (a.1) the active dump_file, if any
 543        (a.2) the -fopt-info destination, if any
 544    (b) the "optinfo" destinations, if any:
 545        (b.1) as optimization records
 546
 547    dump_* (MSG_*) --> dumpfile.c --> items --> (a.1) dump_file
 548                                        |   `-> (a.2) alt_dump_file
 549                                        |
 550                                        `--> (b) optinfo
 551                                                 `---> optinfo destinations
 552                                                       (b.1) optimization records
 553
 554    For optinfos, the dump_*_loc mark the beginning of an optinfo
 555    instance: all subsequent dump_* calls are consolidated into
 556    that optinfo, until the next dump_*_loc call (or a change in
 557    dump scope, or a call to dumpfile_ensure_any_optinfo_are_flushed).
 558
 559    A group of dump_* calls should be guarded by:
 560
 561      if (dump_enabled_p ())
 562
 563    to minimize the work done for the common case where dumps
 564    are disabled.  */
 565
 566 extern void dump_printf (const dump_metadata_t &, const char *, ...)
 567   ATTRIBUTE_GCC_DUMP_PRINTF (2, 3);
 568
 569 extern void dump_printf_loc (const dump_metadata_t &, const dump_user_location_t &,
 570                              const char *, ...)
 571   ATTRIBUTE_GCC_DUMP_PRINTF (3, 0);
 572 extern void dump_function (int phase, tree fn);
 573 extern void dump_basic_block (dump_flags_t, basic_block, int);
 574 extern void dump_generic_expr_loc (const dump_metadata_t &,
 575                                    const dump_user_location_t &,
 576                                    dump_flags_t, tree);
 577 extern void dump_generic_expr (const dump_metadata_t &, dump_flags_t, tree);
 578 extern void dump_gimple_stmt_loc (const dump_metadata_t &,
 579                                   const dump_user_location_t &,
 580                                   dump_flags_t, gimple *, int);
 581 extern void dump_gimple_stmt (const dump_metadata_t &, dump_flags_t, gimple *, int);
 582 extern void dump_gimple_expr_loc (const dump_metadata_t &,
 583                                   const dump_user_location_t &,
 584                                   dump_flags_t, gimple *, int);
 585 extern void dump_gimple_expr (const dump_metadata_t &, dump_flags_t, gimple *, int);
 586 extern void dump_symtab_node (const dump_metadata_t &, symtab_node *);
 587
 588 template<unsigned int N, typename C>
 589 void dump_dec (const dump_metadata_t &, const poly_int<N, C> &);
 590 extern void dump_dec (dump_flags_t, const poly_wide_int &, signop);
 591 extern void dump_hex (dump_flags_t, const poly_wide_int &);
 592
 593 extern void dumpfile_ensure_any_optinfo_are_flushed ();
 594
 595 /* Managing nested scopes, so that dumps can express the call chain
 596    leading to a dump message.  */
 597
 598 extern unsigned int get_dump_scope_depth ();
 599 extern void dump_begin_scope (const char *name,
 600                               const dump_user_location_t &user_location,
 601                               const dump_impl_location_t &impl_location);
 602 extern void dump_end_scope ();
 603
 604 /* Implementation detail of the AUTO_DUMP_SCOPE macro below.
 605
 606    A RAII-style class intended to make it easy to emit dump
 607    information about entering and exiting a collection of nested
 608    function calls.  */
 609
 610 class auto_dump_scope
 611 {
 612  public:
 613   auto_dump_scope (const char *name,
 614                    const dump_user_location_t &user_location,
 615                    const dump_impl_location_t &impl_location
 616                    = dump_impl_location_t ())
 617   {
 618     if (dump_enabled_p ())
 619       dump_begin_scope (name, user_location, impl_location);
 620   }
 621   ~auto_dump_scope ()
 622   {
 623     if (dump_enabled_p ())
 624       dump_end_scope ();
 625   }
 626 };
 627
 628 /* A macro for calling:
 629      dump_begin_scope (NAME, USER_LOC);
 630    via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc,
 631    and then calling
 632      dump_end_scope ();
 633    once the object goes out of scope, thus capturing the nesting of
 634    the scopes.
 635
 636    These scopes affect dump messages within them: dump messages at the
 637    top level implicitly default to MSG_PRIORITY_USER_FACING, whereas those
 638    in a nested scope implicitly default to MSG_PRIORITY_INTERNALS.  */
 639
 640 #define AUTO_DUMP_SCOPE(NAME, USER_LOC) \
 641   auto_dump_scope scope (NAME, USER_LOC)
 642
 643 extern void dump_function (int phase, tree fn);
 644 extern void print_combine_total_stats (void);
 645 extern bool enable_rtl_dump_file (void);
 646
 647 /* In tree-dump.c  */
 648 extern void dump_node (const_tree, dump_flags_t, FILE *);
 649
 650 /* In combine.c  */
 651 extern void dump_combine_total_stats (FILE *);
 652 /* In cfghooks.c  */
 653 extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
 654
 655 class opt_pass;
 656
 657 namespace gcc {
 658
 659 /* A class for managing all of the various dump files used by the
 660    optimization passes.  */
 661
 662 class dump_manager
 663 {
 664 public:
 665
 666   dump_manager ();
 667   ~dump_manager ();
 668
 669   /* Register a dumpfile.
 670
 671      TAKE_OWNERSHIP determines whether callee takes ownership of strings
 672      SUFFIX, SWTCH, and GLOB. */
 673   unsigned int
 674   dump_register (const char *suffix, const char *swtch, const char *glob,
 675                  dump_kind dkind, optgroup_flags_t optgroup_flags,
 676                  bool take_ownership);
 677
 678   /* Allow languages and middle-end to register their dumps before the
 679      optimization passes.  */
 680   void
 681   register_dumps ();
 682
 683   /* Return the dump_file_info for the given phase.  */
 684   struct dump_file_info *
 685   get_dump_file_info (int phase) const;
 686
 687   struct dump_file_info *
 688   get_dump_file_info_by_switch (const char *swtch) const;
 689
 690   /* Return the name of the dump file for the given phase.
 691      If the dump is not enabled, returns NULL.  */
 692   char *
 693   get_dump_file_name (int phase, int part = -1) const;
 694
 695   char *
 696   get_dump_file_name (struct dump_file_info *dfi, int part = -1) const;
 697
 698   void
 699   dump_switch_p (const char *arg);
 700
 701   /* Start a dump for PHASE. Store user-supplied dump flags in
 702      *FLAG_PTR.  Return the number of streams opened.  Set globals
 703      DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and
 704      set dump_flags appropriately for both pass dump stream and
 705      -fopt-info stream. */
 706   int
 707   dump_start (int phase, dump_flags_t *flag_ptr);
 708
 709   /* Finish a tree dump for PHASE and close associated dump streams.  Also
 710      reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS.  */
 711   void
 712   dump_finish (int phase);
 713
 714   FILE *
 715   dump_begin (int phase, dump_flags_t *flag_ptr, int part);
 716
 717   /* Returns nonzero if tree dump PHASE has been initialized.  */
 718   int
 719   dump_initialized_p (int phase) const;
 720
 721   /* Returns the switch name of PHASE.  */
 722   const char *
 723   dump_flag_name (int phase) const;
 724
 725   void register_pass (opt_pass *pass);
 726
 727 private:
 728
 729   int
 730   dump_phase_enabled_p (int phase) const;
 731
 732   int
 733   dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob);
 734
 735   int
 736   dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename);
 737
 738   int
 739   opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
 740                           const char *filename);
 741
 742   bool update_dfi_for_opt_info (dump_file_info *dfi) const;
 743
 744 private:
 745
 746   /* Dynamically registered dump files and switches.  */
 747   int m_next_dump;
 748   struct dump_file_info *m_extra_dump_files;
 749   size_t m_extra_dump_files_in_use;
 750   size_t m_extra_dump_files_alloced;
 751
 752   /* Stored values from -fopt-info, for handling passes created after
 753      option-parsing (by backends and by plugins).  */
 754   optgroup_flags_t m_optgroup_flags;
 755   dump_flags_t m_optinfo_flags;
 756   char *m_optinfo_filename;
 757
 758   /* Grant access to dump_enable_all.  */
 759   friend bool ::enable_rtl_dump_file (void);
 760
 761   /* Grant access to opt_info_enable_passes.  */
 762   friend int ::opt_info_switch_p (const char *arg);
 763
 764 }; // class dump_manager
 765
 766 } // namespace gcc
 767
 768 #endif /* GCC_DUMPFILE_H */