gcc/diagnostic.c

   1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
   2    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009 Free Software Foundation, Inc.
   4    Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 /* This file implements the language independent aspect of diagnostic
  24    message module.  */
  25
  26 #include "config.h"
  27 #undef FLOAT /* This is for hpux. They should change hpux.  */
  28 #undef FFS  /* Some systems define this in param.h.  */
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "tree.h"
  33 #include "version.h"
  34 #include "tm_p.h"
  35 #include "flags.h"
  36 #include "input.h"
  37 #include "toplev.h"
  38 #include "intl.h"
  39 #include "diagnostic.h"
  40 #include "langhooks.h"
  41 #include "langhooks-def.h"
  42 #include "opts.h"
  43 #include "plugin.h"
  44
  45 #define pedantic_warning_kind() (flag_pedantic_errors ? DK_ERROR : DK_WARNING)
  46 #define permissive_error_kind() (flag_permissive ? DK_WARNING : DK_ERROR)
  47
  48 /* Prototypes.  */
  49 static char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
  50
  51 static void default_diagnostic_starter (diagnostic_context *,
  52                                         diagnostic_info *);
  53 static void default_diagnostic_finalizer (diagnostic_context *,
  54                                           diagnostic_info *);
  55
  56 static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
  57
  58 static void diagnostic_action_after_output (diagnostic_context *,
  59                                             diagnostic_info *);
  60 static void real_abort (void) ATTRIBUTE_NORETURN;
  61
  62 /* A diagnostic_context surrogate for stderr.  */
  63 static diagnostic_context global_diagnostic_context;
  64 diagnostic_context *global_dc = &global_diagnostic_context;
  65
  66 \f
  67 /* Return a malloc'd string containing MSG formatted a la printf.  The
  68    caller is responsible for freeing the memory.  */
  69 static char *
  70 build_message_string (const char *msg, ...)
  71 {
  72   char *str;
  73   va_list ap;
  74
  75   va_start (ap, msg);
  76   vasprintf (&str, msg, ap);
  77   va_end (ap);
  78
  79   return str;
  80 }
  81
  82 /* Same as diagnostic_build_prefix, but only the source FILE is given.  */
  83 char *
  84 file_name_as_prefix (const char *f)
  85 {
  86   return build_message_string ("%s: ", f);
  87 }
  88
  89
  90 \f
  91 /* Initialize the diagnostic message outputting machinery.  */
  92 void
  93 diagnostic_initialize (diagnostic_context *context)
  94 {
  95   /* Allocate a basic pretty-printer.  Clients will replace this a
  96      much more elaborated pretty-printer if they wish.  */
  97   context->printer = XNEW (pretty_printer);
  98   pp_construct (context->printer, NULL, 0);
  99   /* By default, diagnostics are sent to stderr.  */
 100   context->printer->buffer->stream = stderr;
 101   /* By default, we emit prefixes once per message.  */
 102   context->printer->wrapping.rule = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 103
 104   memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
 105   context->issue_warnings_are_errors_message = true;
 106   context->warning_as_error_requested = false;
 107   memset (context->classify_diagnostic, DK_UNSPECIFIED,
 108           sizeof context->classify_diagnostic);
 109   context->show_option_requested = false;
 110   context->abort_on_error = false;
 111   context->internal_error = NULL;
 112   diagnostic_starter (context) = default_diagnostic_starter;
 113   diagnostic_finalizer (context) = default_diagnostic_finalizer;
 114   context->last_module = 0;
 115   context->last_function = NULL;
 116   context->lock = 0;
 117 }
 118
 119 /* Initialize DIAGNOSTIC, where the message MSG has already been
 120    translated.  */
 121 void
 122 diagnostic_set_info_translated (diagnostic_info *diagnostic, const char *msg,
 123                                 va_list *args, location_t location,
 124                                 diagnostic_t kind)
 125 {
 126   diagnostic->message.err_no = errno;
 127   diagnostic->message.args_ptr = args;
 128   diagnostic->message.format_spec = msg;
 129   diagnostic->location = location;
 130   diagnostic->override_column = 0;
 131   diagnostic->kind = kind;
 132   diagnostic->option_index = 0;
 133 }
 134
 135 /* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
 136    translated.  */
 137 void
 138 diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid,
 139                      va_list *args, location_t location,
 140                      diagnostic_t kind)
 141 {
 142   diagnostic_set_info_translated (diagnostic, _(gmsgid), args, location, kind);
 143 }
 144
 145 /* Return a malloc'd string describing a location.  The caller is
 146    responsible for freeing the memory.  */
 147 char *
 148 diagnostic_build_prefix (diagnostic_info *diagnostic)
 149 {
 150   static const char *const diagnostic_kind_text[] = {
 151 #define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
 152 #include "diagnostic.def"
 153 #undef DEFINE_DIAGNOSTIC_KIND
 154     "must-not-happen"
 155   };
 156   const char *text = _(diagnostic_kind_text[diagnostic->kind]);
 157   expanded_location s = expand_location (diagnostic->location);
 158   if (diagnostic->override_column)
 159     s.column = diagnostic->override_column;
 160   gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
 161
 162   return
 163     (s.file == NULL
 164      ? build_message_string ("%s: %s", progname, text)
 165      : flag_show_column && s.column != 0
 166      ? build_message_string ("%s:%d:%d: %s", s.file, s.line, s.column, text)
 167      : build_message_string ("%s:%d: %s", s.file, s.line, text));
 168 }
 169
 170 /* Take any action which is expected to happen after the diagnostic
 171    is written out.  This function does not always return.  */
 172 static void
 173 diagnostic_action_after_output (diagnostic_context *context,
 174                                 diagnostic_info *diagnostic)
 175 {
 176   switch (diagnostic->kind)
 177     {
 178     case DK_DEBUG:
 179     case DK_NOTE:
 180     case DK_ANACHRONISM:
 181     case DK_WARNING:
 182       break;
 183
 184     case DK_ERROR:
 185     case DK_SORRY:
 186       if (context->abort_on_error)
 187         real_abort ();
 188       if (flag_fatal_errors)
 189         {
 190           fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
 191           exit (FATAL_EXIT_CODE);
 192         }
 193       break;
 194
 195     case DK_ICE:
 196       if (context->abort_on_error)
 197         real_abort ();
 198
 199       fnotice (stderr, "Please submit a full bug report,\n"
 200                "with preprocessed source if appropriate.\n"
 201                "See %s for instructions.\n", bug_report_url);
 202       exit (ICE_EXIT_CODE);
 203
 204     case DK_FATAL:
 205       if (context->abort_on_error)
 206         real_abort ();
 207
 208       fnotice (stderr, "compilation terminated.\n");
 209       exit (FATAL_EXIT_CODE);
 210
 211     default:
 212       gcc_unreachable ();
 213     }
 214 }
 215
 216 /* Prints out, if necessary, the name of the current function
 217    that caused an error.  Called from all error and warning functions.  */
 218 void
 219 diagnostic_report_current_function (diagnostic_context *context,
 220                                     diagnostic_info *diagnostic)
 221 {
 222   diagnostic_report_current_module (context);
 223   lang_hooks.print_error_function (context, input_filename, diagnostic);
 224 }
 225
 226 void
 227 diagnostic_report_current_module (diagnostic_context *context)
 228 {
 229   const struct line_map *map;
 230
 231   if (pp_needs_newline (context->printer))
 232     {
 233       pp_newline (context->printer);
 234       pp_needs_newline (context->printer) = false;
 235     }
 236
 237   if (input_location <= BUILTINS_LOCATION)
 238     return;
 239
 240   map = linemap_lookup (line_table, input_location);
 241   if (map && diagnostic_last_module_changed (context, map))
 242     {
 243       diagnostic_set_last_module (context, map);
 244       if (! MAIN_FILE_P (map))
 245         {
 246           map = INCLUDED_FROM (line_table, map);
 247           pp_verbatim (context->printer,
 248                        "In file included from %s:%d",
 249                        map->to_file, LAST_SOURCE_LINE (map));
 250           while (! MAIN_FILE_P (map))
 251             {
 252               map = INCLUDED_FROM (line_table, map);
 253               pp_verbatim (context->printer,
 254                            ",\n                 from %s:%d",
 255                            map->to_file, LAST_SOURCE_LINE (map));
 256             }
 257           pp_verbatim (context->printer, ":");
 258           pp_newline (context->printer);
 259         }
 260     }
 261 }
 262
 263 static void
 264 default_diagnostic_starter (diagnostic_context *context,
 265                             diagnostic_info *diagnostic)
 266 {
 267   diagnostic_report_current_function (context, diagnostic);
 268   pp_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
 269 }
 270
 271 static void
 272 default_diagnostic_finalizer (diagnostic_context *context,
 273                               diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
 274 {
 275   pp_destroy_prefix (context->printer);
 276 }
 277
 278 /* Interface to specify diagnostic kind overrides.  Returns the
 279    previous setting, or DK_UNSPECIFIED if the parameters are out of
 280    range.  */
 281 diagnostic_t
 282 diagnostic_classify_diagnostic (diagnostic_context *context,
 283                                 int option_index,
 284                                 diagnostic_t new_kind)
 285 {
 286   diagnostic_t old_kind;
 287
 288   if (option_index <= 0
 289       || option_index >= N_OPTS
 290       || new_kind >= DK_LAST_DIAGNOSTIC_KIND)
 291     return DK_UNSPECIFIED;
 292
 293   old_kind = context->classify_diagnostic[option_index];
 294   context->classify_diagnostic[option_index] = new_kind;
 295   return old_kind;
 296 }
 297
 298 /* Report a diagnostic message (an error or a warning) as specified by
 299    DC.  This function is *the* subroutine in terms of which front-ends
 300    should implement their specific diagnostic handling modules.  The
 301    front-end independent format specifiers are exactly those described
 302    in the documentation of output_format.
 303    Return true if a diagnostic was printed, false otherwise.  */
 304
 305 bool
 306 diagnostic_report_diagnostic (diagnostic_context *context,
 307                               diagnostic_info *diagnostic)
 308 {
 309   location_t location = diagnostic->location;
 310   bool maybe_print_warnings_as_errors_message = false;
 311   const char *saved_format_spec;
 312
 313   /* Give preference to being able to inhibit warnings, before they
 314      get reclassified to something else.  */
 315   if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN)
 316       && !diagnostic_report_warnings_p (location))
 317     return false;
 318
 319   if (diagnostic->kind == DK_PEDWARN)
 320     diagnostic->kind = pedantic_warning_kind ();
 321
 322   if (context->lock > 0)
 323     {
 324       /* If we're reporting an ICE in the middle of some other error,
 325          try to flush out the previous error, then let this one
 326          through.  Don't do this more than once.  */
 327       if (diagnostic->kind == DK_ICE && context->lock == 1)
 328         pp_flush (context->printer);
 329       else
 330         error_recursion (context);
 331     }
 332
 333   /* If the user requested that warnings be treated as errors, so be
 334      it.  Note that we do this before the next block so that
 335      individual warnings can be overridden back to warnings with
 336      -Wno-error=*.  */
 337   if (context->warning_as_error_requested
 338       && diagnostic->kind == DK_WARNING)
 339     {
 340       diagnostic->kind = DK_ERROR;
 341       maybe_print_warnings_as_errors_message = true;
 342     }
 343
 344   if (diagnostic->option_index)
 345     {
 346       /* This tests if the user provided the appropriate -Wfoo or
 347          -Wno-foo option.  */
 348       if (! option_enabled (diagnostic->option_index))
 349         return false;
 350       /* This tests if the user provided the appropriate -Werror=foo
 351          option.  */
 352       if (context->classify_diagnostic[diagnostic->option_index] != DK_UNSPECIFIED)
 353         {
 354           diagnostic->kind = context->classify_diagnostic[diagnostic->option_index];
 355           maybe_print_warnings_as_errors_message = false;
 356         }
 357       /* This allows for future extensions, like temporarily disabling
 358          warnings for ranges of source code.  */
 359       if (diagnostic->kind == DK_IGNORED)
 360         return false;
 361     }
 362
 363   /* If we changed the kind due to -Werror, and didn't override it, we
 364      need to print this message.  */
 365   if (context->issue_warnings_are_errors_message
 366       && maybe_print_warnings_as_errors_message)
 367     {
 368       pp_verbatim (context->printer,
 369                    "%s: warnings being treated as errors\n", progname);
 370       context->issue_warnings_are_errors_message = false;
 371     }
 372
 373   context->lock++;
 374
 375   if (diagnostic->kind == DK_ICE && plugins_active_p ())
 376     {
 377       fnotice (stderr, "*** WARNING *** there are active plugins, do not report"
 378                " this as a bug unless you can reproduce it without enabling"
 379                " any plugins.\n");
 380       dump_active_plugins (stderr);
 381     }
 382
 383   if (diagnostic->kind == DK_ICE)
 384     {
 385 #ifndef ENABLE_CHECKING
 386       /* When not checking, ICEs are converted to fatal errors when an
 387          error has already occurred.  This is counteracted by
 388          abort_on_error.  */
 389       if ((diagnostic_kind_count (context, DK_ERROR) > 0
 390            || diagnostic_kind_count (context, DK_SORRY) > 0)
 391           && !context->abort_on_error)
 392         {
 393           expanded_location s = expand_location (diagnostic->location);
 394           fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
 395                    s.file, s.line);
 396           exit (ICE_EXIT_CODE);
 397         }
 398 #endif
 399       if (context->internal_error)
 400         (*context->internal_error) (diagnostic->message.format_spec,
 401                                     diagnostic->message.args_ptr);
 402     }
 403   ++diagnostic_kind_count (context, diagnostic->kind);
 404
 405   saved_format_spec = diagnostic->message.format_spec;
 406   if (context->show_option_requested && diagnostic->option_index)
 407     diagnostic->message.format_spec
 408       = ACONCAT ((diagnostic->message.format_spec,
 409                   " [", cl_options[diagnostic->option_index].opt_text, "]", NULL));
 410
 411   diagnostic->message.locus = &diagnostic->location;
 412   diagnostic->message.abstract_origin = &diagnostic->abstract_origin;
 413   diagnostic->abstract_origin = NULL;
 414   pp_format (context->printer, &diagnostic->message);
 415   (*diagnostic_starter (context)) (context, diagnostic);
 416   pp_output_formatted_text (context->printer);
 417   (*diagnostic_finalizer (context)) (context, diagnostic);
 418   pp_flush (context->printer);
 419   diagnostic_action_after_output (context, diagnostic);
 420   diagnostic->message.format_spec = saved_format_spec;
 421   diagnostic->abstract_origin = NULL;
 422
 423   context->lock--;
 424
 425   return true;
 426 }
 427
 428 /* Given a partial pathname as input, return another pathname that
 429    shares no directory elements with the pathname of __FILE__.  This
 430    is used by fancy_abort() to print `Internal compiler error in expr.c'
 431    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
 432
 433 const char *
 434 trim_filename (const char *name)
 435 {
 436   static const char this_file[] = __FILE__;
 437   const char *p = name, *q = this_file;
 438
 439   /* First skip any "../" in each filename.  This allows us to give a proper
 440      reference to a file in a subdirectory.  */
 441   while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
 442     p += 3;
 443
 444   while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
 445     q += 3;
 446
 447   /* Now skip any parts the two filenames have in common.  */
 448   while (*p == *q && *p != 0 && *q != 0)
 449     p++, q++;
 450
 451   /* Now go backwards until the previous directory separator.  */
 452   while (p > name && !IS_DIR_SEPARATOR (p[-1]))
 453     p--;
 454
 455   return p;
 456 }
 457 \f
 458 /* Standard error reporting routines in increasing order of severity.
 459    All of these take arguments like printf.  */
 460
 461 /* Text to be emitted verbatim to the error message stream; this
 462    produces no prefix and disables line-wrapping.  Use rarely.  */
 463 void
 464 verbatim (const char *gmsgid, ...)
 465 {
 466   text_info text;
 467   va_list ap;
 468
 469   va_start (ap, gmsgid);
 470   text.err_no = errno;
 471   text.args_ptr = &ap;
 472   text.format_spec = _(gmsgid);
 473   text.locus = NULL;
 474   text.abstract_origin = NULL;
 475   pp_format_verbatim (global_dc->printer, &text);
 476   pp_flush (global_dc->printer);
 477   va_end (ap);
 478 }
 479
 480 bool
 481 emit_diagnostic (diagnostic_t kind, location_t location, int opt,
 482                  const char *gmsgid, ...)
 483 {
 484   diagnostic_info diagnostic;
 485   va_list ap;
 486
 487   va_start (ap, gmsgid);
 488   if (kind == DK_PERMERROR)
 489     {
 490       diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
 491                            permissive_error_kind ());
 492       diagnostic.option_index = OPT_fpermissive;
 493     }
 494   else {
 495       diagnostic_set_info (&diagnostic, gmsgid, &ap, location, kind);
 496       if (kind == DK_WARNING || kind == DK_PEDWARN)
 497         diagnostic.option_index = opt;
 498   }
 499   va_end (ap);
 500
 501   return report_diagnostic (&diagnostic);
 502 }
 503
 504 /* An informative note at LOCATION.  Use this for additional details on an error
 505    message.  */
 506 void
 507 inform (location_t location, const char *gmsgid, ...)
 508 {
 509   diagnostic_info diagnostic;
 510   va_list ap;
 511
 512   va_start (ap, gmsgid);
 513   diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_NOTE);
 514   report_diagnostic (&diagnostic);
 515   va_end (ap);
 516 }
 517
 518 /* A warning at INPUT_LOCATION.  Use this for code which is correct according
 519    to the relevant language specification but is likely to be buggy anyway.
 520    Returns true if the warning was printed, false if it was inhibited.  */
 521 bool
 522 warning (int opt, const char *gmsgid, ...)
 523 {
 524   diagnostic_info diagnostic;
 525   va_list ap;
 526
 527   va_start (ap, gmsgid);
 528   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING);
 529   diagnostic.option_index = opt;
 530
 531   va_end (ap);
 532   return report_diagnostic (&diagnostic);
 533 }
 534
 535 /* A warning at LOCATION.  Use this for code which is correct according to the
 536    relevant language specification but is likely to be buggy anyway.
 537    Returns true if the warning was printed, false if it was inhibited.  */
 538
 539 bool
 540 warning_at (location_t location, int opt, const char *gmsgid, ...)
 541 {
 542   diagnostic_info diagnostic;
 543   va_list ap;
 544
 545   va_start (ap, gmsgid);
 546   diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_WARNING);
 547   diagnostic.option_index = opt;
 548   va_end (ap);
 549   return report_diagnostic (&diagnostic);
 550 }
 551
 552 /* A "pedantic" warning at LOCATION: issues a warning unless
 553    -pedantic-errors was given on the command line, in which case it
 554    issues an error.  Use this for diagnostics required by the relevant
 555    language standard, if you have chosen not to make them errors.
 556
 557    Note that these diagnostics are issued independent of the setting
 558    of the -pedantic command-line switch.  To get a warning enabled
 559    only with that switch, use either "if (pedantic) pedwarn
 560    (OPT_pedantic,...)" or just "pedwarn (OPT_pedantic,..)".  To get a
 561    pedwarn independently of the -pedantic switch use "pedwarn (0,...)".
 562
 563    Returns true if the warning was printed, false if it was inhibited.  */
 564
 565 bool
 566 pedwarn (location_t location, int opt, const char *gmsgid, ...)
 567 {
 568   diagnostic_info diagnostic;
 569   va_list ap;
 570
 571   va_start (ap, gmsgid);
 572   diagnostic_set_info (&diagnostic, gmsgid, &ap, location,  DK_PEDWARN);
 573   diagnostic.option_index = opt;
 574   va_end (ap);
 575   return report_diagnostic (&diagnostic);
 576 }
 577
 578 /* A "permissive" error at LOCATION: issues an error unless
 579    -fpermissive was given on the command line, in which case it issues
 580    a warning.  Use this for things that really should be errors but we
 581    want to support legacy code.
 582
 583    Returns true if the warning was printed, false if it was inhibited.  */
 584
 585 bool
 586 permerror (location_t location, const char *gmsgid, ...)
 587 {
 588   diagnostic_info diagnostic;
 589   va_list ap;
 590
 591   va_start (ap, gmsgid);
 592   diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
 593                        permissive_error_kind ());
 594   diagnostic.option_index = OPT_fpermissive;
 595   va_end (ap);
 596   return report_diagnostic (&diagnostic);
 597 }
 598
 599 /* A hard error: the code is definitely ill-formed, and an object file
 600    will not be produced.  */
 601 void
 602 error (const char *gmsgid, ...)
 603 {
 604   diagnostic_info diagnostic;
 605   va_list ap;
 606
 607   va_start (ap, gmsgid);
 608   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ERROR);
 609   report_diagnostic (&diagnostic);
 610   va_end (ap);
 611 }
 612
 613 /* Same as ebove, but use location LOC instead of input_location.  */
 614 void
 615 error_at (location_t loc, const char *gmsgid, ...)
 616 {
 617   diagnostic_info diagnostic;
 618   va_list ap;
 619
 620   va_start (ap, gmsgid);
 621   diagnostic_set_info (&diagnostic, gmsgid, &ap, loc, DK_ERROR);
 622   report_diagnostic (&diagnostic);
 623   va_end (ap);
 624 }
 625
 626 /* "Sorry, not implemented."  Use for a language feature which is
 627    required by the relevant specification but not implemented by GCC.
 628    An object file will not be produced.  */
 629 void
 630 sorry (const char *gmsgid, ...)
 631 {
 632   diagnostic_info diagnostic;
 633   va_list ap;
 634
 635   va_start (ap, gmsgid);
 636   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_SORRY);
 637   report_diagnostic (&diagnostic);
 638   va_end (ap);
 639 }
 640
 641 /* An error which is severe enough that we make no attempt to
 642    continue.  Do not use this for internal consistency checks; that's
 643    internal_error.  Use of this function should be rare.  */
 644 void
 645 fatal_error (const char *gmsgid, ...)
 646 {
 647   diagnostic_info diagnostic;
 648   va_list ap;
 649
 650   va_start (ap, gmsgid);
 651   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_FATAL);
 652   report_diagnostic (&diagnostic);
 653   va_end (ap);
 654
 655   gcc_unreachable ();
 656 }
 657
 658 /* An internal consistency check has failed.  We make no attempt to
 659    continue.  Note that unless there is debugging value to be had from
 660    a more specific message, or some other good reason, you should use
 661    abort () instead of calling this function directly.  */
 662 void
 663 internal_error (const char *gmsgid, ...)
 664 {
 665   diagnostic_info diagnostic;
 666   va_list ap;
 667
 668   va_start (ap, gmsgid);
 669   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ICE);
 670   report_diagnostic (&diagnostic);
 671   va_end (ap);
 672
 673   gcc_unreachable ();
 674 }
 675 \f
 676 /* Special case error functions.  Most are implemented in terms of the
 677    above, or should be.  */
 678
 679 /* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
 680    runs its second argument through gettext.  */
 681 void
 682 fnotice (FILE *file, const char *cmsgid, ...)
 683 {
 684   va_list ap;
 685
 686   va_start (ap, cmsgid);
 687   vfprintf (file, _(cmsgid), ap);
 688   va_end (ap);
 689 }
 690
 691 /* Inform the user that an error occurred while trying to report some
 692    other error.  This indicates catastrophic internal inconsistencies,
 693    so give up now.  But do try to flush out the previous error.
 694    This mustn't use internal_error, that will cause infinite recursion.  */
 695
 696 static void
 697 error_recursion (diagnostic_context *context)
 698 {
 699   diagnostic_info diagnostic;
 700
 701   if (context->lock < 3)
 702     pp_flush (context->printer);
 703
 704   fnotice (stderr,
 705            "Internal compiler error: Error reporting routines re-entered.\n");
 706
 707   /* Call diagnostic_action_after_output to get the "please submit a bug
 708      report" message.  It only looks at the kind field of diagnostic_info.  */
 709   diagnostic.kind = DK_ICE;
 710   diagnostic_action_after_output (context, &diagnostic);
 711
 712   /* Do not use gcc_unreachable here; that goes through internal_error
 713      and therefore would cause infinite recursion.  */
 714   real_abort ();
 715 }
 716
 717 /* Report an internal compiler error in a friendly manner.  This is
 718    the function that gets called upon use of abort() in the source
 719    code generally, thanks to a special macro.  */
 720
 721 void
 722 fancy_abort (const char *file, int line, const char *function)
 723 {
 724   internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
 725 }
 726
 727 /* Really call the system 'abort'.  This has to go right at the end of
 728    this file, so that there are no functions after it that call abort
 729    and get the system abort instead of our macro.  */
 730 #undef abort
 731 static void
 732 real_abort (void)
 733 {
 734   abort ();
 735 }