gcc/dumpfile.c

   1 /* Dump infrastructure for optimizations and intermediate representation.
   2    Copyright (C) 2012-2014 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 it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 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 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "diagnostic-core.h"
  24 #include "dumpfile.h"
  25 #include "tree.h"
  26 #include "gimple-pretty-print.h"
  27 #include "context.h"
  28
  29 /* If non-NULL, return one past-the-end of the matching SUBPART of
  30    the WHOLE string.  */
  31 #define skip_leading_substring(whole,  part) \
  32    (strncmp (whole, part, strlen (part)) ? NULL : whole + strlen (part))
  33
  34 static int pflags;                   /* current dump_flags */
  35 static int alt_flags;                /* current opt_info flags */
  36
  37 static void dump_loc (int, FILE *, source_location);
  38 static FILE *dump_open_alternate_stream (struct dump_file_info *);
  39
  40 /* These are currently used for communicating between passes.
  41    However, instead of accessing them directly, the passes can use
  42    dump_printf () for dumps.  */
  43 FILE *dump_file = NULL;
  44 FILE *alt_dump_file = NULL;
  45 const char *dump_file_name;
  46 int dump_flags;
  47
  48 /* Table of tree dump switches. This must be consistent with the
  49    TREE_DUMP_INDEX enumeration in dumpfile.h.  */
  50 static struct dump_file_info dump_files[TDI_end] =
  51 {
  52   {NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0, 0, 0},
  53   {".cgraph", "ipa-cgraph", NULL, NULL, NULL, NULL, NULL, TDF_IPA,
  54    0, 0, 0, 0, 0},
  55   {".type-inheritance", "ipa-type-inheritance", NULL, NULL, NULL, NULL, NULL, TDF_IPA,
  56    0, 0, 0, 0, 0},
  57   {".tu", "translation-unit", NULL, NULL, NULL, NULL, NULL, TDF_TREE,
  58    0, 0, 0, 0, 1},
  59   {".class", "class-hierarchy", NULL, NULL, NULL, NULL, NULL, TDF_TREE,
  60    0, 0, 0, 0, 2},
  61   {".original", "tree-original", NULL, NULL, NULL, NULL, NULL, TDF_TREE,
  62    0, 0, 0, 0, 3},
  63   {".gimple", "tree-gimple", NULL, NULL, NULL, NULL, NULL, TDF_TREE,
  64    0, 0, 0, 0, 4},
  65   {".nested", "tree-nested", NULL, NULL, NULL, NULL, NULL, TDF_TREE,
  66    0, 0, 0, 0, 5},
  67 #define FIRST_AUTO_NUMBERED_DUMP 6
  68
  69   {NULL, "tree-all", NULL, NULL, NULL, NULL, NULL, TDF_TREE,
  70    0, 0, 0, 0, 0},
  71   {NULL, "rtl-all", NULL, NULL, NULL, NULL, NULL, TDF_RTL,
  72    0, 0, 0, 0, 0},
  73   {NULL, "ipa-all", NULL, NULL, NULL, NULL, NULL, TDF_IPA,
  74    0, 0, 0, 0, 0},
  75 };
  76
  77 /* Define a name->number mapping for a dump flag value.  */
  78 struct dump_option_value_info
  79 {
  80   const char *const name;       /* the name of the value */
  81   const int value;              /* the value of the name */
  82 };
  83
  84 /* Table of dump options. This must be consistent with the TDF_* flags
  85    in dumpfile.h and opt_info_options below. */
  86 static const struct dump_option_value_info dump_options[] =
  87 {
  88   {"address", TDF_ADDRESS},
  89   {"asmname", TDF_ASMNAME},
  90   {"slim", TDF_SLIM},
  91   {"raw", TDF_RAW},
  92   {"graph", TDF_GRAPH},
  93   {"details", (TDF_DETAILS | MSG_OPTIMIZED_LOCATIONS
  94                | MSG_MISSED_OPTIMIZATION
  95                | MSG_NOTE)},
  96   {"cselib", TDF_CSELIB},
  97   {"stats", TDF_STATS},
  98   {"blocks", TDF_BLOCKS},
  99   {"vops", TDF_VOPS},
 100   {"lineno", TDF_LINENO},
 101   {"uid", TDF_UID},
 102   {"stmtaddr", TDF_STMTADDR},
 103   {"memsyms", TDF_MEMSYMS},
 104   {"verbose", TDF_VERBOSE},
 105   {"eh", TDF_EH},
 106   {"alias", TDF_ALIAS},
 107   {"nouid", TDF_NOUID},
 108   {"enumerate_locals", TDF_ENUMERATE_LOCALS},
 109   {"scev", TDF_SCEV},
 110   {"optimized", MSG_OPTIMIZED_LOCATIONS},
 111   {"missed", MSG_MISSED_OPTIMIZATION},
 112   {"note", MSG_NOTE},
 113   {"optall", MSG_ALL},
 114   {"all", ~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_TREE | TDF_RTL | TDF_IPA
 115             | TDF_STMTADDR | TDF_GRAPH | TDF_DIAGNOSTIC | TDF_VERBOSE
 116             | TDF_RHS_ONLY | TDF_NOUID | TDF_ENUMERATE_LOCALS | TDF_SCEV)},
 117   {NULL, 0}
 118 };
 119
 120 /* A subset of the dump_options table which is used for -fopt-info
 121    types. This must be consistent with the MSG_* flags in dumpfile.h.
 122  */
 123 static const struct dump_option_value_info optinfo_verbosity_options[] =
 124 {
 125   {"optimized", MSG_OPTIMIZED_LOCATIONS},
 126   {"missed", MSG_MISSED_OPTIMIZATION},
 127   {"note", MSG_NOTE},
 128   {"all", MSG_ALL},
 129   {NULL, 0}
 130 };
 131
 132 /* Flags used for -fopt-info groups.  */
 133 static const struct dump_option_value_info optgroup_options[] =
 134 {
 135   {"ipa", OPTGROUP_IPA},
 136   {"loop", OPTGROUP_LOOP},
 137   {"inline", OPTGROUP_INLINE},
 138   {"vec", OPTGROUP_VEC},
 139   {"optall", OPTGROUP_ALL},
 140   {NULL, 0}
 141 };
 142
 143 gcc::dump_manager::dump_manager ():
 144   m_next_dump (FIRST_AUTO_NUMBERED_DUMP),
 145   m_extra_dump_files (NULL),
 146   m_extra_dump_files_in_use (0),
 147   m_extra_dump_files_alloced (0)
 148 {
 149 }
 150
 151 unsigned int
 152 gcc::dump_manager::
 153 dump_register (const char *suffix, const char *swtch, const char *glob,
 154                int flags, int optgroup_flags)
 155 {
 156   int num = m_next_dump++;
 157
 158   size_t count = m_extra_dump_files_in_use++;
 159
 160   if (count >= m_extra_dump_files_alloced)
 161     {
 162       if (m_extra_dump_files_alloced == 0)
 163         m_extra_dump_files_alloced = 32;
 164       else
 165         m_extra_dump_files_alloced *= 2;
 166       m_extra_dump_files = XRESIZEVEC (struct dump_file_info,
 167                                        m_extra_dump_files,
 168                                        m_extra_dump_files_alloced);
 169     }
 170
 171   memset (&m_extra_dump_files[count], 0, sizeof (struct dump_file_info));
 172   m_extra_dump_files[count].suffix = suffix;
 173   m_extra_dump_files[count].swtch = swtch;
 174   m_extra_dump_files[count].glob = glob;
 175   m_extra_dump_files[count].pflags = flags;
 176   m_extra_dump_files[count].optgroup_flags = optgroup_flags;
 177   m_extra_dump_files[count].num = num;
 178
 179   return count + TDI_end;
 180 }
 181
 182
 183 /* Return the dump_file_info for the given phase.  */
 184
 185 struct dump_file_info *
 186 gcc::dump_manager::
 187 get_dump_file_info (int phase) const
 188 {
 189   if (phase < TDI_end)
 190     return &dump_files[phase];
 191   else if ((size_t) (phase - TDI_end) >= m_extra_dump_files_in_use)
 192     return NULL;
 193   else
 194     return m_extra_dump_files + (phase - TDI_end);
 195 }
 196
 197
 198 /* Return the name of the dump file for the given phase.
 199    If the dump is not enabled, returns NULL.  */
 200
 201 char *
 202 gcc::dump_manager::
 203 get_dump_file_name (int phase) const
 204 {
 205   char dump_id[10];
 206   struct dump_file_info *dfi;
 207
 208   if (phase == TDI_none)
 209     return NULL;
 210
 211   dfi = get_dump_file_info (phase);
 212   if (dfi->pstate == 0)
 213     return NULL;
 214
 215   /* If available, use the command line dump filename. */
 216   if (dfi->pfilename)
 217     return xstrdup (dfi->pfilename);
 218
 219   if (dfi->num < 0)
 220     dump_id[0] = '\0';
 221   else
 222     {
 223       char suffix;
 224       if (dfi->pflags & TDF_TREE)
 225         suffix = 't';
 226       else if (dfi->pflags & TDF_IPA)
 227         suffix = 'i';
 228       else
 229         suffix = 'r';
 230
 231       if (snprintf (dump_id, sizeof (dump_id), ".%03d%c", dfi->num, suffix) < 0)
 232         dump_id[0] = '\0';
 233     }
 234
 235   return concat (dump_base_name, dump_id, dfi->suffix, NULL);
 236 }
 237
 238 /* For a given DFI, open an alternate dump filename (which could also
 239    be a standard stream such as stdout/stderr). If the alternate dump
 240    file cannot be opened, return NULL.  */
 241
 242 static FILE *
 243 dump_open_alternate_stream (struct dump_file_info *dfi)
 244 {
 245   FILE *stream ;
 246   if (!dfi->alt_filename)
 247     return NULL;
 248
 249   if (dfi->alt_stream)
 250     return dfi->alt_stream;
 251
 252   stream = strcmp ("stderr", dfi->alt_filename) == 0
 253     ? stderr
 254     : strcmp ("stdout", dfi->alt_filename) == 0
 255     ? stdout
 256     : fopen (dfi->alt_filename, dfi->alt_state < 0 ? "w" : "a");
 257
 258   if (!stream)
 259     error ("could not open dump file %qs: %m", dfi->alt_filename);
 260   else
 261     dfi->alt_state = 1;
 262
 263   return stream;
 264 }
 265
 266 /* Print source location on DFILE if enabled.  */
 267
 268 void
 269 dump_loc (int dump_kind, FILE *dfile, source_location loc)
 270 {
 271   if (dump_kind)
 272     {
 273       if (LOCATION_LOCUS (loc) > BUILTINS_LOCATION)
 274         fprintf (dfile, "%s:%d:%d: note: ", LOCATION_FILE (loc),
 275                  LOCATION_LINE (loc), LOCATION_COLUMN (loc));
 276       else if (current_function_decl)
 277         fprintf (dfile, "%s:%d:%d: note: ",
 278                  DECL_SOURCE_FILE (current_function_decl),
 279                  DECL_SOURCE_LINE (current_function_decl),
 280                  DECL_SOURCE_COLUMN (current_function_decl));
 281     }
 282 }
 283
 284 /* Dump gimple statement GS with SPC indentation spaces and
 285    EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled.  */
 286
 287 void
 288 dump_gimple_stmt (int dump_kind, int extra_dump_flags, gimple gs, int spc)
 289 {
 290   if (dump_file && (dump_kind & pflags))
 291     print_gimple_stmt (dump_file, gs, spc, dump_flags | extra_dump_flags);
 292
 293   if (alt_dump_file && (dump_kind & alt_flags))
 294     print_gimple_stmt (alt_dump_file, gs, spc, dump_flags | extra_dump_flags);
 295 }
 296
 297 /* Similar to dump_gimple_stmt, except additionally print source location.  */
 298
 299 void
 300 dump_gimple_stmt_loc (int dump_kind, source_location loc, int extra_dump_flags,
 301                       gimple gs, int spc)
 302 {
 303   if (dump_file && (dump_kind & pflags))
 304     {
 305       dump_loc (dump_kind, dump_file, loc);
 306       print_gimple_stmt (dump_file, gs, spc, dump_flags | extra_dump_flags);
 307     }
 308
 309   if (alt_dump_file && (dump_kind & alt_flags))
 310     {
 311       dump_loc (dump_kind, alt_dump_file, loc);
 312       print_gimple_stmt (alt_dump_file, gs, spc, dump_flags | extra_dump_flags);
 313     }
 314 }
 315
 316 /* Dump expression tree T using EXTRA_DUMP_FLAGS on dump streams if
 317    DUMP_KIND is enabled.  */
 318
 319 void
 320 dump_generic_expr (int dump_kind, int extra_dump_flags, tree t)
 321 {
 322   if (dump_file && (dump_kind & pflags))
 323       print_generic_expr (dump_file, t, dump_flags | extra_dump_flags);
 324
 325   if (alt_dump_file && (dump_kind & alt_flags))
 326       print_generic_expr (alt_dump_file, t, dump_flags | extra_dump_flags);
 327 }
 328
 329
 330 /* Similar to dump_generic_expr, except additionally print the source
 331    location.  */
 332
 333 void
 334 dump_generic_expr_loc (int dump_kind, source_location loc,
 335                        int extra_dump_flags, tree t)
 336 {
 337   if (dump_file && (dump_kind & pflags))
 338     {
 339       dump_loc (dump_kind, dump_file, loc);
 340       print_generic_expr (dump_file, t, dump_flags | extra_dump_flags);
 341     }
 342
 343   if (alt_dump_file && (dump_kind & alt_flags))
 344     {
 345       dump_loc (dump_kind, alt_dump_file, loc);
 346       print_generic_expr (alt_dump_file, t, dump_flags | extra_dump_flags);
 347     }
 348 }
 349
 350 /* Output a formatted message using FORMAT on appropriate dump streams.  */
 351
 352 void
 353 dump_printf (int dump_kind, const char *format, ...)
 354 {
 355   if (dump_file && (dump_kind & pflags))
 356     {
 357       va_list ap;
 358       va_start (ap, format);
 359       vfprintf (dump_file, format, ap);
 360       va_end (ap);
 361     }
 362
 363   if (alt_dump_file && (dump_kind & alt_flags))
 364     {
 365       va_list ap;
 366       va_start (ap, format);
 367       vfprintf (alt_dump_file, format, ap);
 368       va_end (ap);
 369     }
 370 }
 371
 372 /* Similar to dump_printf, except source location is also printed.  */
 373
 374 void
 375 dump_printf_loc (int dump_kind, source_location loc, const char *format, ...)
 376 {
 377   if (dump_file && (dump_kind & pflags))
 378     {
 379       va_list ap;
 380       dump_loc (dump_kind, dump_file, loc);
 381       va_start (ap, format);
 382       vfprintf (dump_file, format, ap);
 383       va_end (ap);
 384     }
 385
 386   if (alt_dump_file && (dump_kind & alt_flags))
 387     {
 388       va_list ap;
 389       dump_loc (dump_kind, alt_dump_file, loc);
 390       va_start (ap, format);
 391       vfprintf (alt_dump_file, format, ap);
 392       va_end (ap);
 393     }
 394 }
 395
 396 /* Start a dump for PHASE. Store user-supplied dump flags in
 397    *FLAG_PTR.  Return the number of streams opened.  Set globals
 398    DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and
 399    set dump_flags appropriately for both pass dump stream and
 400    -fopt-info stream. */
 401
 402 int
 403 gcc::dump_manager::
 404 dump_start (int phase, int *flag_ptr)
 405 {
 406   int count = 0;
 407   char *name;
 408   struct dump_file_info *dfi;
 409   FILE *stream;
 410   if (phase == TDI_none || !dump_phase_enabled_p (phase))
 411     return 0;
 412
 413   dfi = get_dump_file_info (phase);
 414   name = get_dump_file_name (phase);
 415   if (name)
 416     {
 417       stream = strcmp ("stderr", name) == 0
 418           ? stderr
 419           : strcmp ("stdout", name) == 0
 420           ? stdout
 421           : fopen (name, dfi->pstate < 0 ? "w" : "a");
 422       if (!stream)
 423         error ("could not open dump file %qs: %m", name);
 424       else
 425         {
 426           dfi->pstate = 1;
 427           count++;
 428         }
 429       free (name);
 430       dfi->pstream = stream;
 431       dump_file = dfi->pstream;
 432       /* Initialize current dump flags. */
 433       pflags = dfi->pflags;
 434     }
 435
 436   stream = dump_open_alternate_stream (dfi);
 437   if (stream)
 438     {
 439       dfi->alt_stream = stream;
 440       count++;
 441       alt_dump_file = dfi->alt_stream;
 442       /* Initialize current -fopt-info flags. */
 443       alt_flags = dfi->alt_flags;
 444     }
 445
 446   if (flag_ptr)
 447     *flag_ptr = dfi->pflags;
 448
 449   return count;
 450 }
 451
 452 /* Finish a tree dump for PHASE and close associated dump streams.  Also
 453    reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS.  */
 454
 455 void
 456 gcc::dump_manager::
 457 dump_finish (int phase)
 458 {
 459   struct dump_file_info *dfi;
 460
 461   if (phase < 0)
 462     return;
 463   dfi = get_dump_file_info (phase);
 464   if (dfi->pstream && (!dfi->pfilename
 465                        || (strcmp ("stderr", dfi->pfilename) != 0
 466                            && strcmp ("stdout", dfi->pfilename) != 0)))
 467     fclose (dfi->pstream);
 468
 469   if (dfi->alt_stream && strcmp ("stderr", dfi->alt_filename) != 0
 470       && strcmp ("stdout", dfi->alt_filename) != 0)
 471     fclose (dfi->alt_stream);
 472
 473   dfi->alt_stream = NULL;
 474   dfi->pstream = NULL;
 475   dump_file = NULL;
 476   alt_dump_file = NULL;
 477   dump_flags = TDI_none;
 478   alt_flags = 0;
 479   pflags = 0;
 480 }
 481
 482 /* Begin a tree dump for PHASE. Stores any user supplied flag in
 483    *FLAG_PTR and returns a stream to write to. If the dump is not
 484    enabled, returns NULL.
 485    Multiple calls will reopen and append to the dump file.  */
 486
 487 FILE *
 488 dump_begin (int phase, int *flag_ptr)
 489 {
 490   return g->get_dumps ()->dump_begin (phase, flag_ptr);
 491 }
 492
 493 FILE *
 494 gcc::dump_manager::
 495 dump_begin (int phase, int *flag_ptr)
 496 {
 497   char *name;
 498   struct dump_file_info *dfi;
 499   FILE *stream;
 500
 501   if (phase == TDI_none || !dump_phase_enabled_p (phase))
 502     return NULL;
 503
 504   name = get_dump_file_name (phase);
 505   if (!name)
 506     return NULL;
 507   dfi = get_dump_file_info (phase);
 508
 509   stream = strcmp ("stderr", name) == 0
 510     ? stderr
 511     : strcmp ("stdout", name) == 0
 512     ? stdout
 513     : fopen (name, dfi->pstate < 0 ? "w" : "a");
 514
 515   if (!stream)
 516     error ("could not open dump file %qs: %m", name);
 517   else
 518     dfi->pstate = 1;
 519   free (name);
 520
 521   if (flag_ptr)
 522     *flag_ptr = dfi->pflags;
 523
 524   /* Initialize current flags */
 525   pflags = dfi->pflags;
 526   return stream;
 527 }
 528
 529 /* Returns nonzero if dump PHASE is enabled for at least one stream.
 530    If PHASE is TDI_tree_all, return nonzero if any dump is enabled for
 531    any phase.  */
 532
 533 int
 534 gcc::dump_manager::
 535 dump_phase_enabled_p (int phase) const
 536 {
 537   if (phase == TDI_tree_all)
 538     {
 539       size_t i;
 540       for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
 541         if (dump_files[i].pstate || dump_files[i].alt_state)
 542           return 1;
 543       for (i = 0; i < m_extra_dump_files_in_use; i++)
 544         if (m_extra_dump_files[i].pstate || m_extra_dump_files[i].alt_state)
 545           return 1;
 546       return 0;
 547     }
 548   else
 549     {
 550       struct dump_file_info *dfi = get_dump_file_info (phase);
 551       return dfi->pstate || dfi->alt_state;
 552     }
 553 }
 554
 555 /* Returns nonzero if tree dump PHASE has been initialized.  */
 556
 557 int
 558 gcc::dump_manager::
 559 dump_initialized_p (int phase) const
 560 {
 561   struct dump_file_info *dfi = get_dump_file_info (phase);
 562   return dfi->pstate > 0 || dfi->alt_state > 0;
 563 }
 564
 565 /* Returns the switch name of PHASE.  */
 566
 567 const char *
 568 dump_flag_name (int phase)
 569 {
 570   return g->get_dumps ()->dump_flag_name (phase);
 571 }
 572
 573 const char *
 574 gcc::dump_manager::
 575 dump_flag_name (int phase) const
 576 {
 577   struct dump_file_info *dfi = get_dump_file_info (phase);
 578   return dfi->swtch;
 579 }
 580
 581 /* Finish a tree dump for PHASE. STREAM is the stream created by
 582    dump_begin.  */
 583
 584 void
 585 dump_end (int phase ATTRIBUTE_UNUSED, FILE *stream)
 586 {
 587   if (stream != stderr && stream != stdout)
 588     fclose (stream);
 589 }
 590
 591 /* Enable all tree dumps with FLAGS on FILENAME.  Return number of
 592    enabled tree dumps.  */
 593
 594 int
 595 gcc::dump_manager::
 596 dump_enable_all (int flags, const char *filename)
 597 {
 598   int ir_dump_type = (flags & (TDF_TREE | TDF_RTL | TDF_IPA));
 599   int n = 0;
 600   size_t i;
 601
 602   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
 603     {
 604       if ((dump_files[i].pflags & ir_dump_type))
 605         {
 606           const char *old_filename = dump_files[i].pfilename;
 607           dump_files[i].pstate = -1;
 608           dump_files[i].pflags |= flags;
 609           n++;
 610           /* Override the existing filename.  */
 611           if (filename)
 612             {
 613               dump_files[i].pfilename = xstrdup (filename);
 614               /* Since it is a command-line provided file, which is
 615                  common to all the phases, use it in append mode.  */
 616               dump_files[i].pstate = 1;
 617             }
 618           if (old_filename && filename != old_filename)
 619             free (CONST_CAST (char *, old_filename));
 620         }
 621     }
 622
 623   for (i = 0; i < m_extra_dump_files_in_use; i++)
 624     {
 625       if ((m_extra_dump_files[i].pflags & ir_dump_type))
 626         {
 627           const char *old_filename = m_extra_dump_files[i].pfilename;
 628           m_extra_dump_files[i].pstate = -1;
 629           m_extra_dump_files[i].pflags |= flags;
 630           n++;
 631           /* Override the existing filename.  */
 632           if (filename)
 633             {
 634               m_extra_dump_files[i].pfilename = xstrdup (filename);
 635               /* Since it is a command-line provided file, which is
 636                  common to all the phases, use it in append mode.  */
 637               m_extra_dump_files[i].pstate = 1;
 638             }
 639           if (old_filename && filename != old_filename)
 640             free (CONST_CAST (char *, old_filename));
 641         }
 642     }
 643
 644   return n;
 645 }
 646
 647 /* Enable -fopt-info dumps on all dump files matching OPTGROUP_FLAGS.
 648    Enable dumps with FLAGS on FILENAME.  Return the number of enabled
 649    dumps.  */
 650
 651 int
 652 gcc::dump_manager::
 653 opt_info_enable_passes (int optgroup_flags, int flags, const char *filename)
 654 {
 655   int n = 0;
 656   size_t i;
 657
 658   for (i = TDI_none + 1; i < (size_t) TDI_end; i++)
 659     {
 660       if ((dump_files[i].optgroup_flags & optgroup_flags))
 661         {
 662           const char *old_filename = dump_files[i].alt_filename;
 663           /* Since this file is shared among different passes, it
 664              should be opened in append mode.  */
 665           dump_files[i].alt_state = 1;
 666           dump_files[i].alt_flags |= flags;
 667           n++;
 668           /* Override the existing filename.  */
 669           if (filename)
 670             dump_files[i].alt_filename = xstrdup (filename);
 671           if (old_filename && filename != old_filename)
 672             free (CONST_CAST (char *, old_filename));
 673         }
 674     }
 675
 676   for (i = 0; i < m_extra_dump_files_in_use; i++)
 677     {
 678       if ((m_extra_dump_files[i].optgroup_flags & optgroup_flags))
 679         {
 680           const char *old_filename = m_extra_dump_files[i].alt_filename;
 681           /* Since this file is shared among different passes, it
 682              should be opened in append mode.  */
 683           m_extra_dump_files[i].alt_state = 1;
 684           m_extra_dump_files[i].alt_flags |= flags;
 685           n++;
 686           /* Override the existing filename.  */
 687           if (filename)
 688             m_extra_dump_files[i].alt_filename = xstrdup (filename);
 689           if (old_filename && filename != old_filename)
 690             free (CONST_CAST (char *, old_filename));
 691         }
 692     }
 693
 694   return n;
 695 }
 696
 697 /* Parse ARG as a dump switch. Return nonzero if it is, and store the
 698    relevant details in the dump_files array.  */
 699
 700 int
 701 gcc::dump_manager::
 702 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob)
 703 {
 704   const char *option_value;
 705   const char *ptr;
 706   int flags;
 707
 708   if (doglob && !dfi->glob)
 709     return 0;
 710
 711   option_value = skip_leading_substring (arg, doglob ? dfi->glob : dfi->swtch);
 712   if (!option_value)
 713     return 0;
 714
 715   if (*option_value && *option_value != '-' && *option_value != '=')
 716     return 0;
 717
 718   ptr = option_value;
 719   flags = 0;
 720
 721   while (*ptr)
 722     {
 723       const struct dump_option_value_info *option_ptr;
 724       const char *end_ptr;
 725       const char *eq_ptr;
 726       unsigned length;
 727
 728       while (*ptr == '-')
 729         ptr++;
 730       end_ptr = strchr (ptr, '-');
 731       eq_ptr = strchr (ptr, '=');
 732
 733       if (eq_ptr && !end_ptr)
 734         end_ptr = eq_ptr;
 735
 736       if (!end_ptr)
 737         end_ptr = ptr + strlen (ptr);
 738       length = end_ptr - ptr;
 739
 740       for (option_ptr = dump_options; option_ptr->name; option_ptr++)
 741         if (strlen (option_ptr->name) == length
 742             && !memcmp (option_ptr->name, ptr, length))
 743           {
 744             flags |= option_ptr->value;
 745             goto found;
 746           }
 747
 748       if (*ptr == '=')
 749         {
 750           /* Interpret rest of the argument as a dump filename.  This
 751              filename overrides other command line filenames.  */
 752           if (dfi->pfilename)
 753             free (CONST_CAST (char *, dfi->pfilename));
 754           dfi->pfilename = xstrdup (ptr + 1);
 755           break;
 756         }
 757       else
 758         warning (0, "ignoring unknown option %q.*s in %<-fdump-%s%>",
 759                  length, ptr, dfi->swtch);
 760     found:;
 761       ptr = end_ptr;
 762     }
 763
 764   dfi->pstate = -1;
 765   dfi->pflags |= flags;
 766
 767   /* Process -fdump-tree-all and -fdump-rtl-all, by enabling all the
 768      known dumps.  */
 769   if (dfi->suffix == NULL)
 770     dump_enable_all (dfi->pflags, dfi->pfilename);
 771
 772   return 1;
 773 }
 774
 775 int
 776 gcc::dump_manager::
 777 dump_switch_p (const char *arg)
 778 {
 779   size_t i;
 780   int any = 0;
 781
 782   for (i = TDI_none + 1; i != TDI_end; i++)
 783     any |= dump_switch_p_1 (arg, &dump_files[i], false);
 784
 785   /* Don't glob if we got a hit already */
 786   if (!any)
 787     for (i = TDI_none + 1; i != TDI_end; i++)
 788       any |= dump_switch_p_1 (arg, &dump_files[i], true);
 789
 790   for (i = 0; i < m_extra_dump_files_in_use; i++)
 791     any |= dump_switch_p_1 (arg, &m_extra_dump_files[i], false);
 792
 793   if (!any)
 794     for (i = 0; i < m_extra_dump_files_in_use; i++)
 795       any |= dump_switch_p_1 (arg, &m_extra_dump_files[i], true);
 796
 797
 798   return any;
 799 }
 800
 801 /* Parse ARG as a -fopt-info switch and store flags, optgroup_flags
 802    and filename.  Return non-zero if it is a recognized switch.  */
 803
 804 static int
 805 opt_info_switch_p_1 (const char *arg, int *flags, int *optgroup_flags,
 806                      char **filename)
 807 {
 808   const char *option_value;
 809   const char *ptr;
 810
 811   option_value = arg;
 812   ptr = option_value;
 813
 814   *filename = NULL;
 815   *flags = 0;
 816   *optgroup_flags = 0;
 817
 818   if (!ptr)
 819     return 1;       /* Handle '-fopt-info' without any additional options.  */
 820
 821   while (*ptr)
 822     {
 823       const struct dump_option_value_info *option_ptr;
 824       const char *end_ptr;
 825       const char *eq_ptr;
 826       unsigned length;
 827
 828       while (*ptr == '-')
 829         ptr++;
 830       end_ptr = strchr (ptr, '-');
 831       eq_ptr = strchr (ptr, '=');
 832
 833       if (eq_ptr && !end_ptr)
 834         end_ptr = eq_ptr;
 835
 836       if (!end_ptr)
 837         end_ptr = ptr + strlen (ptr);
 838       length = end_ptr - ptr;
 839
 840       for (option_ptr = optinfo_verbosity_options; option_ptr->name;
 841            option_ptr++)
 842         if (strlen (option_ptr->name) == length
 843             && !memcmp (option_ptr->name, ptr, length))
 844           {
 845             *flags |= option_ptr->value;
 846             goto found;
 847           }
 848
 849       for (option_ptr = optgroup_options; option_ptr->name; option_ptr++)
 850         if (strlen (option_ptr->name) == length
 851             && !memcmp (option_ptr->name, ptr, length))
 852           {
 853             *optgroup_flags |= option_ptr->value;
 854             goto found;
 855           }
 856
 857       if (*ptr == '=')
 858         {
 859           /* Interpret rest of the argument as a dump filename.  This
 860              filename overrides other command line filenames.  */
 861           *filename = xstrdup (ptr + 1);
 862           break;
 863         }
 864       else
 865         {
 866           warning (0, "unknown option %q.*s in %<-fopt-info-%s%>",
 867                    length, ptr, arg);
 868           return 0;
 869         }
 870     found:;
 871       ptr = end_ptr;
 872     }
 873
 874   return 1;
 875 }
 876
 877 /* Return non-zero if ARG is a recognized switch for
 878    -fopt-info. Return zero otherwise.  */
 879
 880 int
 881 opt_info_switch_p (const char *arg)
 882 {
 883   int flags;
 884   int optgroup_flags;
 885   char *filename;
 886   static char *file_seen = NULL;
 887   gcc::dump_manager *dumps = g->get_dumps ();
 888
 889   if (!opt_info_switch_p_1 (arg, &flags, &optgroup_flags, &filename))
 890     return 0;
 891
 892   if (!filename)
 893     filename = xstrdup ("stderr");
 894
 895   /* Bail out if a different filename has been specified.  */
 896   if (file_seen && strcmp (file_seen, filename))
 897     {
 898       warning (0, "ignoring possibly conflicting option %<-fopt-info-%s%>",
 899                arg);
 900       return 1;
 901     }
 902
 903   file_seen = xstrdup (filename);
 904   if (!flags)
 905     flags = MSG_OPTIMIZED_LOCATIONS;
 906   if (!optgroup_flags)
 907     optgroup_flags = OPTGROUP_ALL;
 908
 909   return dumps->opt_info_enable_passes (optgroup_flags, flags, filename);
 910 }
 911
 912 /* Print basic block on the dump streams.  */
 913
 914 void
 915 dump_basic_block (int dump_kind, basic_block bb, int indent)
 916 {
 917   if (dump_file && (dump_kind & pflags))
 918     dump_bb (dump_file, bb, indent, TDF_DETAILS);
 919   if (alt_dump_file && (dump_kind & alt_flags))
 920     dump_bb (alt_dump_file, bb, indent, TDF_DETAILS);
 921 }
 922
 923 /* Print information from the combine pass on dump_file.  */
 924
 925 void
 926 print_combine_total_stats (void)
 927 {
 928   if (dump_file)
 929     dump_combine_total_stats (dump_file);
 930 }
 931
 932 /* Enable RTL dump for all the RTL passes.  */
 933
 934 bool
 935 enable_rtl_dump_file (void)
 936 {
 937   gcc::dump_manager *dumps = g->get_dumps ();
 938   int num_enabled =
 939     dumps->dump_enable_all (TDF_RTL | TDF_DETAILS | TDF_BLOCKS, NULL);
 940   return num_enabled > 0;
 941 }