gcc/dumpfile.h

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