gcc/dumpfile.h

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