gcc/dumpfile.c

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