gcc/diagnostic.c

   1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
   2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   3    Contributed by Gabriel Dos Reis <gdr@codesourcery.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21
  22 /* This file implements the language independent aspect of diagnostic
  23    message module.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "version.h"
  29 #include "demangle.h"
  30 #include "input.h"
  31 #include "intl.h"
  32 #include "backtrace.h"
  33 #include "diagnostic.h"
  34 #include "diagnostic-color.h"
  35
  36 #include <new>                     // For placement new.
  37
  38 #define pedantic_warning_kind(DC)                       \
  39   ((DC)->pedantic_errors ? DK_ERROR : DK_WARNING)
  40 #define permissive_error_kind(DC) ((DC)->permissive ? DK_WARNING : DK_ERROR)
  41 #define permissive_error_option(DC) ((DC)->opt_permissive)
  42
  43 /* Prototypes.  */
  44 static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
  45
  46 static void diagnostic_action_after_output (diagnostic_context *,
  47                                             diagnostic_info *);
  48 static void real_abort (void) ATTRIBUTE_NORETURN;
  49
  50 /* Name of program invoked, sans directories.  */
  51
  52 const char *progname;
  53
  54 /* A diagnostic_context surrogate for stderr.  */
  55 static diagnostic_context global_diagnostic_context;
  56 diagnostic_context *global_dc = &global_diagnostic_context;
  57 \f
  58 /* Return a malloc'd string containing MSG formatted a la printf.  The
  59    caller is responsible for freeing the memory.  */
  60 char *
  61 build_message_string (const char *msg, ...)
  62 {
  63   char *str;
  64   va_list ap;
  65
  66   va_start (ap, msg);
  67   vasprintf (&str, msg, ap);
  68   va_end (ap);
  69
  70   return str;
  71 }
  72
  73 /* Same as diagnostic_build_prefix, but only the source FILE is given.  */
  74 char *
  75 file_name_as_prefix (diagnostic_context *context, const char *f)
  76 {
  77   const char *locus_cs
  78     = colorize_start (pp_show_color (context->printer), "locus");
  79   const char *locus_ce = colorize_stop (pp_show_color (context->printer));
  80   return build_message_string ("%s%s:%s ", locus_cs, f, locus_ce);
  81 }
  82
  83
  84 \f
  85 /* Return the value of the getenv("COLUMNS") as an integer. If the
  86    value is not set to a positive integer, then return INT_MAX.  */
  87 static int
  88 getenv_columns (void)
  89 {
  90   const char * s = getenv ("COLUMNS");
  91   if (s != NULL) {
  92     int n = atoi (s);
  93     if (n > 0)
  94       return n;
  95   }
  96   return INT_MAX;
  97 }
  98
  99 /* Set caret_max_width to value.  */
 100 void
 101 diagnostic_set_caret_max_width (diagnostic_context *context, int value)
 102 {
 103   /* One minus to account for the leading empty space.  */
 104   value = value ? value - 1
 105     : (isatty (fileno (pp_buffer (context->printer)->stream))
 106        ? getenv_columns () - 1: INT_MAX);
 107
 108   if (value <= 0)
 109     value = INT_MAX;
 110
 111   context->caret_max_width = value;
 112 }
 113
 114 /* Initialize the diagnostic message outputting machinery.  */
 115 void
 116 diagnostic_initialize (diagnostic_context *context, int n_opts)
 117 {
 118   int i;
 119
 120   /* Allocate a basic pretty-printer.  Clients will replace this a
 121      much more elaborated pretty-printer if they wish.  */
 122   context->printer = XNEW (pretty_printer);
 123   new (context->printer) pretty_printer ();
 124
 125   memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
 126   context->some_warnings_are_errors = false;
 127   context->warning_as_error_requested = false;
 128   context->n_opts = n_opts;
 129   context->classify_diagnostic = XNEWVEC (diagnostic_t, n_opts);
 130   for (i = 0; i < n_opts; i++)
 131     context->classify_diagnostic[i] = DK_UNSPECIFIED;
 132   context->show_caret = false;
 133   diagnostic_set_caret_max_width (context, pp_line_cutoff (context->printer));
 134   context->caret_char = '^';
 135   context->show_option_requested = false;
 136   context->abort_on_error = false;
 137   context->show_column = false;
 138   context->pedantic_errors = false;
 139   context->permissive = false;
 140   context->opt_permissive = 0;
 141   context->fatal_errors = false;
 142   context->dc_inhibit_warnings = false;
 143   context->dc_warn_system_headers = false;
 144   context->max_errors = 0;
 145   context->internal_error = NULL;
 146   diagnostic_starter (context) = default_diagnostic_starter;
 147   diagnostic_finalizer (context) = default_diagnostic_finalizer;
 148   context->option_enabled = NULL;
 149   context->option_state = NULL;
 150   context->option_name = NULL;
 151   context->last_location = UNKNOWN_LOCATION;
 152   context->last_module = 0;
 153   context->x_data = NULL;
 154   context->lock = 0;
 155   context->inhibit_notes_p = false;
 156 }
 157
 158 /* Do any cleaning up required after the last diagnostic is emitted.  */
 159
 160 void
 161 diagnostic_finish (diagnostic_context *context)
 162 {
 163   /* Some of the errors may actually have been warnings.  */
 164   if (context->some_warnings_are_errors)
 165     {
 166       /* -Werror was given.  */
 167       if (context->warning_as_error_requested)
 168         pp_verbatim (context->printer,
 169                      _("%s: all warnings being treated as errors"),
 170                      progname);
 171       /* At least one -Werror= was given.  */
 172       else
 173         pp_verbatim (context->printer,
 174                      _("%s: some warnings being treated as errors"),
 175                      progname);
 176       pp_newline_and_flush (context->printer);
 177     }
 178
 179   diagnostic_file_cache_fini ();
 180
 181   XDELETEVEC (context->classify_diagnostic);
 182   context->classify_diagnostic = NULL;
 183
 184   /* diagnostic_initialize allocates context->printer using XNEW
 185      and placement-new.  */
 186   context->printer->~pretty_printer ();
 187   XDELETE (context->printer);
 188   context->printer = NULL;
 189 }
 190
 191 /* Initialize DIAGNOSTIC, where the message MSG has already been
 192    translated.  */
 193 void
 194 diagnostic_set_info_translated (diagnostic_info *diagnostic, const char *msg,
 195                                 va_list *args, location_t location,
 196                                 diagnostic_t kind)
 197 {
 198   diagnostic->message.err_no = errno;
 199   diagnostic->message.args_ptr = args;
 200   diagnostic->message.format_spec = msg;
 201   diagnostic->location = location;
 202   diagnostic->override_column = 0;
 203   diagnostic->kind = kind;
 204   diagnostic->option_index = 0;
 205 }
 206
 207 /* Initialize DIAGNOSTIC, where the message GMSGID has not yet been
 208    translated.  */
 209 void
 210 diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid,
 211                      va_list *args, location_t location,
 212                      diagnostic_t kind)
 213 {
 214   diagnostic_set_info_translated (diagnostic, _(gmsgid), args, location, kind);
 215 }
 216
 217 /* Return a malloc'd string describing a location.  The caller is
 218    responsible for freeing the memory.  */
 219 char *
 220 diagnostic_build_prefix (diagnostic_context *context,
 221                          const diagnostic_info *diagnostic)
 222 {
 223   static const char *const diagnostic_kind_text[] = {
 224 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (T),
 225 #include "diagnostic.def"
 226 #undef DEFINE_DIAGNOSTIC_KIND
 227     "must-not-happen"
 228   };
 229   static const char *const diagnostic_kind_color[] = {
 230 #define DEFINE_DIAGNOSTIC_KIND(K, T, C) (C),
 231 #include "diagnostic.def"
 232 #undef DEFINE_DIAGNOSTIC_KIND
 233     NULL
 234   };
 235   const char *text = _(diagnostic_kind_text[diagnostic->kind]);
 236   const char *text_cs = "", *text_ce = "";
 237   const char *locus_cs, *locus_ce;
 238   pretty_printer *pp = context->printer;
 239
 240   if (diagnostic_kind_color[diagnostic->kind])
 241     {
 242       text_cs = colorize_start (pp_show_color (pp),
 243                                 diagnostic_kind_color[diagnostic->kind]);
 244       text_ce = colorize_stop (pp_show_color (pp));
 245     }
 246   locus_cs = colorize_start (pp_show_color (pp), "locus");
 247   locus_ce = colorize_stop (pp_show_color (pp));
 248
 249   expanded_location s = expand_location_to_spelling_point (diagnostic->location);
 250   if (diagnostic->override_column)
 251     s.column = diagnostic->override_column;
 252   gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
 253
 254   return
 255     (s.file == NULL
 256      ? build_message_string ("%s%s:%s %s%s%s", locus_cs, progname, locus_ce,
 257                              text_cs, text, text_ce)
 258      : !strcmp (s.file, N_("<built-in>"))
 259      ? build_message_string ("%s%s:%s %s%s%s", locus_cs, s.file, locus_ce,
 260                              text_cs, text, text_ce)
 261      : context->show_column
 262      ? build_message_string ("%s%s:%d:%d:%s %s%s%s", locus_cs, s.file, s.line,
 263                              s.column, locus_ce, text_cs, text, text_ce)
 264      : build_message_string ("%s%s:%d:%s %s%s%s", locus_cs, s.file, s.line, locus_ce,
 265                              text_cs, text, text_ce));
 266 }
 267
 268 /* If LINE is longer than MAX_WIDTH, and COLUMN is not smaller than
 269    MAX_WIDTH by some margin, then adjust the start of the line such
 270    that the COLUMN is smaller than MAX_WIDTH minus the margin.  The
 271    margin is either 10 characters or the difference between the column
 272    and the length of the line, whatever is smaller.  The length of
 273    LINE is given by LINE_WIDTH.  */
 274 static const char *
 275 adjust_line (const char *line, int line_width,
 276              int max_width, int *column_p)
 277 {
 278   int right_margin = 10;
 279   int column = *column_p;
 280
 281   gcc_checking_assert (line_width >= column);
 282   right_margin = MIN (line_width - column, right_margin);
 283   right_margin = max_width - right_margin;
 284   if (line_width >= max_width && column > right_margin)
 285     {
 286       line += column - right_margin;
 287       *column_p = right_margin;
 288     }
 289   return line;
 290 }
 291
 292 /* Print the physical source line corresponding to the location of
 293    this diagnostic, and a caret indicating the precise column.  */
 294 void
 295 diagnostic_show_locus (diagnostic_context * context,
 296                        const diagnostic_info *diagnostic)
 297 {
 298   const char *line;
 299   int line_width;
 300   char *buffer;
 301   expanded_location s;
 302   int max_width;
 303   const char *saved_prefix;
 304   const char *caret_cs, *caret_ce;
 305
 306   if (!context->show_caret
 307       || diagnostic->location <= BUILTINS_LOCATION
 308       || diagnostic->location == context->last_location)
 309     return;
 310
 311   context->last_location = diagnostic->location;
 312   s = expand_location_to_spelling_point (diagnostic->location);
 313   line = location_get_source_line (s, &line_width);
 314   if (line == NULL || s.column > line_width)
 315     return;
 316
 317   max_width = context->caret_max_width;
 318   line = adjust_line (line, line_width, max_width, &(s.column));
 319
 320   pp_newline (context->printer);
 321   saved_prefix = pp_get_prefix (context->printer);
 322   pp_set_prefix (context->printer, NULL);
 323   pp_space (context->printer);
 324   while (max_width > 0 && line_width > 0)
 325     {
 326       char c = *line == '\t' ? ' ' : *line;
 327       if (c == '\0')
 328         c = ' ';
 329       pp_character (context->printer, c);
 330       max_width--;
 331       line_width--;
 332       line++;
 333     }
 334   pp_newline (context->printer);
 335   caret_cs = colorize_start (pp_show_color (context->printer), "caret");
 336   caret_ce = colorize_stop (pp_show_color (context->printer));
 337
 338   /* pp_printf does not implement %*c.  */
 339   size_t len = s.column + 3 + strlen (caret_cs) + strlen (caret_ce);
 340   buffer = XALLOCAVEC (char, len);
 341   snprintf (buffer, len, "%s %*c%s", caret_cs, s.column, context->caret_char,
 342             caret_ce);
 343   pp_string (context->printer, buffer);
 344   pp_set_prefix (context->printer, saved_prefix);
 345   pp_needs_newline (context->printer) = true;
 346 }
 347
 348 /* Functions at which to stop the backtrace print.  It's not
 349    particularly helpful to print the callers of these functions.  */
 350
 351 static const char * const bt_stop[] =
 352 {
 353   "main",
 354   "toplev::main",
 355   "execute_one_pass",
 356   "compile_file",
 357 };
 358
 359 /* A callback function passed to the backtrace_full function.  */
 360
 361 static int
 362 bt_callback (void *data, uintptr_t pc, const char *filename, int lineno,
 363              const char *function)
 364 {
 365   int *pcount = (int *) data;
 366
 367   /* If we don't have any useful information, don't print
 368      anything.  */
 369   if (filename == NULL && function == NULL)
 370     return 0;
 371
 372   /* Skip functions in diagnostic.c.  */
 373   if (*pcount == 0
 374       && filename != NULL
 375       && strcmp (lbasename (filename), "diagnostic.c") == 0)
 376     return 0;
 377
 378   /* Print up to 20 functions.  We could make this a --param, but
 379      since this is only for debugging just use a constant for now.  */
 380   if (*pcount >= 20)
 381     {
 382       /* Returning a non-zero value stops the backtrace.  */
 383       return 1;
 384     }
 385   ++*pcount;
 386
 387   char *alc = NULL;
 388   if (function != NULL)
 389     {
 390       char *str = cplus_demangle_v3 (function,
 391                                      (DMGL_VERBOSE | DMGL_ANSI
 392                                       | DMGL_GNU_V3 | DMGL_PARAMS));
 393       if (str != NULL)
 394         {
 395           alc = str;
 396           function = str;
 397         }
 398
 399       for (size_t i = 0; i < ARRAY_SIZE (bt_stop); ++i)
 400         {
 401           size_t len = strlen (bt_stop[i]);
 402           if (strncmp (function, bt_stop[i], len) == 0
 403               && (function[len] == '\0' || function[len] == '('))
 404             {
 405               if (alc != NULL)
 406                 free (alc);
 407               /* Returning a non-zero value stops the backtrace.  */
 408               return 1;
 409             }
 410         }
 411     }
 412
 413   fprintf (stderr, "0x%lx %s\n\t%s:%d\n",
 414            (unsigned long) pc,
 415            function == NULL ? "???" : function,
 416            filename == NULL ? "???" : filename,
 417            lineno);
 418
 419   if (alc != NULL)
 420     free (alc);
 421
 422   return 0;
 423 }
 424
 425 /* A callback function passed to the backtrace_full function.  This is
 426    called if backtrace_full has an error.  */
 427
 428 static void
 429 bt_err_callback (void *data ATTRIBUTE_UNUSED, const char *msg, int errnum)
 430 {
 431   if (errnum < 0)
 432     {
 433       /* This means that no debug info was available.  Just quietly
 434          skip printing backtrace info.  */
 435       return;
 436     }
 437   fprintf (stderr, "%s%s%s\n", msg, errnum == 0 ? "" : ": ",
 438            errnum == 0 ? "" : xstrerror (errnum));
 439 }
 440
 441 /* Take any action which is expected to happen after the diagnostic
 442    is written out.  This function does not always return.  */
 443 static void
 444 diagnostic_action_after_output (diagnostic_context *context,
 445                                 diagnostic_info *diagnostic)
 446 {
 447   switch (diagnostic->kind)
 448     {
 449     case DK_DEBUG:
 450     case DK_NOTE:
 451     case DK_ANACHRONISM:
 452     case DK_WARNING:
 453       break;
 454
 455     case DK_ERROR:
 456     case DK_SORRY:
 457       if (context->abort_on_error)
 458         real_abort ();
 459       if (context->fatal_errors)
 460         {
 461           fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
 462           diagnostic_finish (context);
 463           exit (FATAL_EXIT_CODE);
 464         }
 465       if (context->max_errors != 0
 466           && ((unsigned) (diagnostic_kind_count (context, DK_ERROR)
 467                           + diagnostic_kind_count (context, DK_SORRY))
 468               >= context->max_errors))
 469         {
 470           fnotice (stderr,
 471                    "compilation terminated due to -fmax-errors=%u.\n",
 472                    context->max_errors);
 473           diagnostic_finish (context);
 474           exit (FATAL_EXIT_CODE);
 475         }
 476       break;
 477
 478     case DK_ICE:
 479       {
 480         struct backtrace_state *state =
 481           backtrace_create_state (NULL, 0, bt_err_callback, NULL);
 482         int count = 0;
 483         if (state != NULL)
 484           backtrace_full (state, 2, bt_callback, bt_err_callback,
 485                           (void *) &count);
 486
 487         if (context->abort_on_error)
 488           real_abort ();
 489
 490         fnotice (stderr, "Please submit a full bug report,\n"
 491                  "with preprocessed source if appropriate.\n");
 492         if (count > 0)
 493           fnotice (stderr,
 494                    ("Please include the complete backtrace "
 495                     "with any bug report.\n"));
 496         fnotice (stderr, "See %s for instructions.\n", bug_report_url);
 497
 498         exit (ICE_EXIT_CODE);
 499       }
 500
 501     case DK_FATAL:
 502       if (context->abort_on_error)
 503         real_abort ();
 504       diagnostic_finish (context);
 505       fnotice (stderr, "compilation terminated.\n");
 506       exit (FATAL_EXIT_CODE);
 507
 508     default:
 509       gcc_unreachable ();
 510     }
 511 }
 512
 513 void
 514 diagnostic_report_current_module (diagnostic_context *context, location_t where)
 515 {
 516   const struct line_map *map = NULL;
 517
 518   if (pp_needs_newline (context->printer))
 519     {
 520       pp_newline (context->printer);
 521       pp_needs_newline (context->printer) = false;
 522     }
 523
 524   if (where <= BUILTINS_LOCATION)
 525     return;
 526
 527   linemap_resolve_location (line_table, where,
 528                             LRK_MACRO_DEFINITION_LOCATION,
 529                             &map);
 530
 531   if (map && diagnostic_last_module_changed (context, map))
 532     {
 533       diagnostic_set_last_module (context, map);
 534       if (! MAIN_FILE_P (map))
 535         {
 536           map = INCLUDED_FROM (line_table, map);
 537           if (context->show_column)
 538             pp_verbatim (context->printer,
 539                          "In file included from %r%s:%d:%d%R", "locus",
 540                          LINEMAP_FILE (map),
 541                          LAST_SOURCE_LINE (map), LAST_SOURCE_COLUMN (map));
 542           else
 543             pp_verbatim (context->printer,
 544                          "In file included from %r%s:%d%R", "locus",
 545                          LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
 546           while (! MAIN_FILE_P (map))
 547             {
 548               map = INCLUDED_FROM (line_table, map);
 549               pp_verbatim (context->printer,
 550                            ",\n                 from %r%s:%d%R", "locus",
 551                            LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
 552             }
 553           pp_verbatim (context->printer, ":");
 554           pp_newline (context->printer);
 555         }
 556     }
 557 }
 558
 559 void
 560 default_diagnostic_starter (diagnostic_context *context,
 561                             diagnostic_info *diagnostic)
 562 {
 563   diagnostic_report_current_module (context, diagnostic->location);
 564   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
 565                                                             diagnostic));
 566 }
 567
 568 void
 569 default_diagnostic_finalizer (diagnostic_context *context,
 570                               diagnostic_info *diagnostic)
 571 {
 572   diagnostic_show_locus (context, diagnostic);
 573   pp_destroy_prefix (context->printer);
 574   pp_newline_and_flush (context->printer);
 575 }
 576
 577 /* Interface to specify diagnostic kind overrides.  Returns the
 578    previous setting, or DK_UNSPECIFIED if the parameters are out of
 579    range.  If OPTION_INDEX is zero, the new setting is for all the
 580    diagnostics.  */
 581 diagnostic_t
 582 diagnostic_classify_diagnostic (diagnostic_context *context,
 583                                 int option_index,
 584                                 diagnostic_t new_kind,
 585                                 location_t where)
 586 {
 587   diagnostic_t old_kind;
 588
 589   if (option_index < 0
 590       || option_index >= context->n_opts
 591       || new_kind >= DK_LAST_DIAGNOSTIC_KIND)
 592     return DK_UNSPECIFIED;
 593
 594   old_kind = context->classify_diagnostic[option_index];
 595
 596   /* Handle pragmas separately, since we need to keep track of *where*
 597      the pragmas were.  */
 598   if (where != UNKNOWN_LOCATION)
 599     {
 600       int i;
 601
 602       /* Record the command-line status, so we can reset it back on DK_POP. */
 603       if (old_kind == DK_UNSPECIFIED)
 604         {
 605           old_kind = context->option_enabled (option_index,
 606                                               context->option_state)
 607             ? DK_WARNING : DK_IGNORED;
 608           context->classify_diagnostic[option_index] = old_kind;
 609         }
 610
 611       for (i = context->n_classification_history - 1; i >= 0; i --)
 612         if (context->classification_history[i].option == option_index)
 613           {
 614             old_kind = context->classification_history[i].kind;
 615             break;
 616           }
 617
 618       i = context->n_classification_history;
 619       context->classification_history =
 620         (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
 621                                                          * sizeof (diagnostic_classification_change_t));
 622       context->classification_history[i].location = where;
 623       context->classification_history[i].option = option_index;
 624       context->classification_history[i].kind = new_kind;
 625       context->n_classification_history ++;
 626     }
 627   else
 628     context->classify_diagnostic[option_index] = new_kind;
 629
 630   return old_kind;
 631 }
 632
 633 /* Save all diagnostic classifications in a stack.  */
 634 void
 635 diagnostic_push_diagnostics (diagnostic_context *context, location_t where ATTRIBUTE_UNUSED)
 636 {
 637   context->push_list = (int *) xrealloc (context->push_list, (context->n_push + 1) * sizeof (int));
 638   context->push_list[context->n_push ++] = context->n_classification_history;
 639 }
 640
 641 /* Restore the topmost classification set off the stack.  If the stack
 642    is empty, revert to the state based on command line parameters.  */
 643 void
 644 diagnostic_pop_diagnostics (diagnostic_context *context, location_t where)
 645 {
 646   int jump_to;
 647   int i;
 648
 649   if (context->n_push)
 650     jump_to = context->push_list [-- context->n_push];
 651   else
 652     jump_to = 0;
 653
 654   i = context->n_classification_history;
 655   context->classification_history =
 656     (diagnostic_classification_change_t *) xrealloc (context->classification_history, (i + 1)
 657                                                      * sizeof (diagnostic_classification_change_t));
 658   context->classification_history[i].location = where;
 659   context->classification_history[i].option = jump_to;
 660   context->classification_history[i].kind = DK_POP;
 661   context->n_classification_history ++;
 662 }
 663
 664 /* Report a diagnostic message (an error or a warning) as specified by
 665    DC.  This function is *the* subroutine in terms of which front-ends
 666    should implement their specific diagnostic handling modules.  The
 667    front-end independent format specifiers are exactly those described
 668    in the documentation of output_format.
 669    Return true if a diagnostic was printed, false otherwise.  */
 670
 671 bool
 672 diagnostic_report_diagnostic (diagnostic_context *context,
 673                               diagnostic_info *diagnostic)
 674 {
 675   location_t location = diagnostic->location;
 676   diagnostic_t orig_diag_kind = diagnostic->kind;
 677   const char *saved_format_spec;
 678
 679   /* Give preference to being able to inhibit warnings, before they
 680      get reclassified to something else.  */
 681   if ((diagnostic->kind == DK_WARNING || diagnostic->kind == DK_PEDWARN)
 682       && !diagnostic_report_warnings_p (context, location))
 683     return false;
 684
 685   if (diagnostic->kind == DK_PEDWARN)
 686     {
 687       diagnostic->kind = pedantic_warning_kind (context);
 688       /* We do this to avoid giving the message for -pedantic-errors.  */
 689       orig_diag_kind = diagnostic->kind;
 690     }
 691
 692   if (diagnostic->kind == DK_NOTE && context->inhibit_notes_p)
 693     return false;
 694
 695   if (context->lock > 0)
 696     {
 697       /* If we're reporting an ICE in the middle of some other error,
 698          try to flush out the previous error, then let this one
 699          through.  Don't do this more than once.  */
 700       if (diagnostic->kind == DK_ICE && context->lock == 1)
 701         pp_newline_and_flush (context->printer);
 702       else
 703         error_recursion (context);
 704     }
 705
 706   /* If the user requested that warnings be treated as errors, so be
 707      it.  Note that we do this before the next block so that
 708      individual warnings can be overridden back to warnings with
 709      -Wno-error=*.  */
 710   if (context->warning_as_error_requested
 711       && diagnostic->kind == DK_WARNING)
 712     {
 713       diagnostic->kind = DK_ERROR;
 714     }
 715
 716   if (diagnostic->option_index
 717       && diagnostic->option_index != permissive_error_option (context))
 718     {
 719       diagnostic_t diag_class = DK_UNSPECIFIED;
 720
 721       /* This tests if the user provided the appropriate -Wfoo or
 722          -Wno-foo option.  */
 723       if (! context->option_enabled (diagnostic->option_index,
 724                                      context->option_state))
 725         return false;
 726
 727       /* This tests for #pragma diagnostic changes.  */
 728       if (context->n_classification_history > 0)
 729         {
 730           /* FIXME: Stupid search.  Optimize later. */
 731           for (int i = context->n_classification_history - 1; i >= 0; i --)
 732             {
 733               if (linemap_location_before_p
 734                   (line_table,
 735                    context->classification_history[i].location,
 736                    location))
 737                 {
 738                   if (context->classification_history[i].kind == (int) DK_POP)
 739                     {
 740                       i = context->classification_history[i].option;
 741                       continue;
 742                     }
 743                   int option = context->classification_history[i].option;
 744                   /* The option 0 is for all the diagnostics.  */
 745                   if (option == 0 || option == diagnostic->option_index)
 746                     {
 747                       diag_class = context->classification_history[i].kind;
 748                       if (diag_class != DK_UNSPECIFIED)
 749                         diagnostic->kind = diag_class;
 750                       break;
 751                     }
 752                 }
 753             }
 754         }
 755       /* This tests if the user provided the appropriate -Werror=foo
 756          option.  */
 757       if (diag_class == DK_UNSPECIFIED
 758           && context->classify_diagnostic[diagnostic->option_index] != DK_UNSPECIFIED)
 759         {
 760           diagnostic->kind = context->classify_diagnostic[diagnostic->option_index];
 761         }
 762       /* This allows for future extensions, like temporarily disabling
 763          warnings for ranges of source code.  */
 764       if (diagnostic->kind == DK_IGNORED)
 765         return false;
 766     }
 767
 768   if (orig_diag_kind == DK_WARNING && diagnostic->kind == DK_ERROR)
 769     context->some_warnings_are_errors = true;
 770
 771   context->lock++;
 772
 773   if (diagnostic->kind == DK_ICE)
 774     {
 775 #ifndef ENABLE_CHECKING
 776       /* When not checking, ICEs are converted to fatal errors when an
 777          error has already occurred.  This is counteracted by
 778          abort_on_error.  */
 779       if ((diagnostic_kind_count (context, DK_ERROR) > 0
 780            || diagnostic_kind_count (context, DK_SORRY) > 0)
 781           && !context->abort_on_error)
 782         {
 783           expanded_location s = expand_location (diagnostic->location);
 784           fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
 785                    s.file, s.line);
 786           exit (ICE_EXIT_CODE);
 787         }
 788 #endif
 789       if (context->internal_error)
 790         (*context->internal_error) (context,
 791                                     diagnostic->message.format_spec,
 792                                     diagnostic->message.args_ptr);
 793     }
 794   if (diagnostic->kind == DK_ERROR && orig_diag_kind == DK_WARNING)
 795     ++diagnostic_kind_count (context, DK_WERROR);
 796   else
 797     ++diagnostic_kind_count (context, diagnostic->kind);
 798
 799   saved_format_spec = diagnostic->message.format_spec;
 800   if (context->show_option_requested)
 801     {
 802       char *option_text;
 803
 804       option_text = context->option_name (context, diagnostic->option_index,
 805                                           orig_diag_kind, diagnostic->kind);
 806
 807       if (option_text)
 808         {
 809           diagnostic->message.format_spec
 810             = ACONCAT ((diagnostic->message.format_spec,
 811                         " ",
 812                         "[", option_text, "]",
 813                         NULL));
 814           free (option_text);
 815         }
 816     }
 817   diagnostic->message.locus = &diagnostic->location;
 818   diagnostic->message.x_data = &diagnostic->x_data;
 819   diagnostic->x_data = NULL;
 820   pp_format (context->printer, &diagnostic->message);
 821   (*diagnostic_starter (context)) (context, diagnostic);
 822   pp_output_formatted_text (context->printer);
 823   (*diagnostic_finalizer (context)) (context, diagnostic);
 824   diagnostic_action_after_output (context, diagnostic);
 825   diagnostic->message.format_spec = saved_format_spec;
 826   diagnostic->x_data = NULL;
 827
 828   context->lock--;
 829
 830   return true;
 831 }
 832
 833 /* Given a partial pathname as input, return another pathname that
 834    shares no directory elements with the pathname of __FILE__.  This
 835    is used by fancy_abort() to print `Internal compiler error in expr.c'
 836    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
 837
 838 const char *
 839 trim_filename (const char *name)
 840 {
 841   static const char this_file[] = __FILE__;
 842   const char *p = name, *q = this_file;
 843
 844   /* First skip any "../" in each filename.  This allows us to give a proper
 845      reference to a file in a subdirectory.  */
 846   while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
 847     p += 3;
 848
 849   while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
 850     q += 3;
 851
 852   /* Now skip any parts the two filenames have in common.  */
 853   while (*p == *q && *p != 0 && *q != 0)
 854     p++, q++;
 855
 856   /* Now go backwards until the previous directory separator.  */
 857   while (p > name && !IS_DIR_SEPARATOR (p[-1]))
 858     p--;
 859
 860   return p;
 861 }
 862 \f
 863 /* Standard error reporting routines in increasing order of severity.
 864    All of these take arguments like printf.  */
 865
 866 /* Text to be emitted verbatim to the error message stream; this
 867    produces no prefix and disables line-wrapping.  Use rarely.  */
 868 void
 869 verbatim (const char *gmsgid, ...)
 870 {
 871   text_info text;
 872   va_list ap;
 873
 874   va_start (ap, gmsgid);
 875   text.err_no = errno;
 876   text.args_ptr = &ap;
 877   text.format_spec = _(gmsgid);
 878   text.locus = NULL;
 879   text.x_data = NULL;
 880   pp_format_verbatim (global_dc->printer, &text);
 881   pp_newline_and_flush (global_dc->printer);
 882   va_end (ap);
 883 }
 884
 885 /* Add a note with text GMSGID and with LOCATION to the diagnostic CONTEXT.  */
 886 void
 887 diagnostic_append_note (diagnostic_context *context,
 888                         location_t location,
 889                         const char * gmsgid, ...)
 890 {
 891   diagnostic_info diagnostic;
 892   va_list ap;
 893   const char *saved_prefix;
 894
 895   va_start (ap, gmsgid);
 896   diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_NOTE);
 897   if (context->inhibit_notes_p)
 898     {
 899       va_end (ap);
 900       return;
 901     }
 902   saved_prefix = pp_get_prefix (context->printer);
 903   pp_set_prefix (context->printer,
 904                  diagnostic_build_prefix (context, &diagnostic));
 905   pp_newline (context->printer);
 906   pp_format (context->printer, &diagnostic.message);
 907   pp_output_formatted_text (context->printer);
 908   pp_destroy_prefix (context->printer);
 909   pp_set_prefix (context->printer, saved_prefix);
 910   diagnostic_show_locus (context, &diagnostic);
 911   va_end (ap);
 912 }
 913
 914 bool
 915 emit_diagnostic (diagnostic_t kind, location_t location, int opt,
 916                  const char *gmsgid, ...)
 917 {
 918   diagnostic_info diagnostic;
 919   va_list ap;
 920   bool ret;
 921
 922   va_start (ap, gmsgid);
 923   if (kind == DK_PERMERROR)
 924     {
 925       diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
 926                            permissive_error_kind (global_dc));
 927       diagnostic.option_index = permissive_error_option (global_dc);
 928     }
 929   else {
 930       diagnostic_set_info (&diagnostic, gmsgid, &ap, location, kind);
 931       if (kind == DK_WARNING || kind == DK_PEDWARN)
 932         diagnostic.option_index = opt;
 933   }
 934
 935   ret = report_diagnostic (&diagnostic);
 936   va_end (ap);
 937   return ret;
 938 }
 939
 940 /* An informative note at LOCATION.  Use this for additional details on an error
 941    message.  */
 942 void
 943 inform (location_t location, const char *gmsgid, ...)
 944 {
 945   diagnostic_info diagnostic;
 946   va_list ap;
 947
 948   va_start (ap, gmsgid);
 949   diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_NOTE);
 950   report_diagnostic (&diagnostic);
 951   va_end (ap);
 952 }
 953
 954 /* An informative note at LOCATION.  Use this for additional details on an
 955    error message.  */
 956 void
 957 inform_n (location_t location, int n, const char *singular_gmsgid,
 958           const char *plural_gmsgid, ...)
 959 {
 960   diagnostic_info diagnostic;
 961   va_list ap;
 962
 963   va_start (ap, plural_gmsgid);
 964   diagnostic_set_info_translated (&diagnostic,
 965                                   ngettext (singular_gmsgid, plural_gmsgid, n),
 966                                   &ap, location, DK_NOTE);
 967   report_diagnostic (&diagnostic);
 968   va_end (ap);
 969 }
 970
 971 /* A warning at INPUT_LOCATION.  Use this for code which is correct according
 972    to the relevant language specification but is likely to be buggy anyway.
 973    Returns true if the warning was printed, false if it was inhibited.  */
 974 bool
 975 warning (int opt, const char *gmsgid, ...)
 976 {
 977   diagnostic_info diagnostic;
 978   va_list ap;
 979   bool ret;
 980
 981   va_start (ap, gmsgid);
 982   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING);
 983   diagnostic.option_index = opt;
 984
 985   ret = report_diagnostic (&diagnostic);
 986   va_end (ap);
 987   return ret;
 988 }
 989
 990 /* A warning at LOCATION.  Use this for code which is correct according to the
 991    relevant language specification but is likely to be buggy anyway.
 992    Returns true if the warning was printed, false if it was inhibited.  */
 993
 994 bool
 995 warning_at (location_t location, int opt, const char *gmsgid, ...)
 996 {
 997   diagnostic_info diagnostic;
 998   va_list ap;
 999   bool ret;
1000
1001   va_start (ap, gmsgid);
1002   diagnostic_set_info (&diagnostic, gmsgid, &ap, location, DK_WARNING);
1003   diagnostic.option_index = opt;
1004   ret = report_diagnostic (&diagnostic);
1005   va_end (ap);
1006   return ret;
1007 }
1008
1009 /* A warning at LOCATION.  Use this for code which is correct according to the
1010    relevant language specification but is likely to be buggy anyway.
1011    Returns true if the warning was printed, false if it was inhibited.  */
1012
1013 bool
1014 warning_n (location_t location, int opt, int n, const char *singular_gmsgid,
1015            const char *plural_gmsgid, ...)
1016 {
1017   diagnostic_info diagnostic;
1018   va_list ap;
1019   bool ret;
1020
1021   va_start (ap, plural_gmsgid);
1022   diagnostic_set_info_translated (&diagnostic,
1023                                   ngettext (singular_gmsgid, plural_gmsgid, n),
1024                                   &ap, location, DK_WARNING);
1025   diagnostic.option_index = opt;
1026   ret = report_diagnostic (&diagnostic);
1027   va_end (ap);
1028   return ret;
1029 }
1030
1031 /* A "pedantic" warning at LOCATION: issues a warning unless
1032    -pedantic-errors was given on the command line, in which case it
1033    issues an error.  Use this for diagnostics required by the relevant
1034    language standard, if you have chosen not to make them errors.
1035
1036    Note that these diagnostics are issued independent of the setting
1037    of the -Wpedantic command-line switch.  To get a warning enabled
1038    only with that switch, use either "if (pedantic) pedwarn
1039    (OPT_Wpedantic,...)" or just "pedwarn (OPT_Wpedantic,..)".  To get a
1040    pedwarn independently of the -Wpedantic switch use "pedwarn (0,...)".
1041
1042    Returns true if the warning was printed, false if it was inhibited.  */
1043
1044 bool
1045 pedwarn (location_t location, int opt, const char *gmsgid, ...)
1046 {
1047   diagnostic_info diagnostic;
1048   va_list ap;
1049   bool ret;
1050
1051   va_start (ap, gmsgid);
1052   diagnostic_set_info (&diagnostic, gmsgid, &ap, location,  DK_PEDWARN);
1053   diagnostic.option_index = opt;
1054   ret = report_diagnostic (&diagnostic);
1055   va_end (ap);
1056   return ret;
1057 }
1058
1059 /* A "permissive" error at LOCATION: issues an error unless
1060    -fpermissive was given on the command line, in which case it issues
1061    a warning.  Use this for things that really should be errors but we
1062    want to support legacy code.
1063
1064    Returns true if the warning was printed, false if it was inhibited.  */
1065
1066 bool
1067 permerror (location_t location, const char *gmsgid, ...)
1068 {
1069   diagnostic_info diagnostic;
1070   va_list ap;
1071   bool ret;
1072
1073   va_start (ap, gmsgid);
1074   diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
1075                        permissive_error_kind (global_dc));
1076   diagnostic.option_index = permissive_error_option (global_dc);
1077   ret = report_diagnostic (&diagnostic);
1078   va_end (ap);
1079   return ret;
1080 }
1081
1082 /* A hard error: the code is definitely ill-formed, and an object file
1083    will not be produced.  */
1084 void
1085 error (const char *gmsgid, ...)
1086 {
1087   diagnostic_info diagnostic;
1088   va_list ap;
1089
1090   va_start (ap, gmsgid);
1091   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ERROR);
1092   report_diagnostic (&diagnostic);
1093   va_end (ap);
1094 }
1095
1096 /* A hard error: the code is definitely ill-formed, and an object file
1097    will not be produced.  */
1098 void
1099 error_n (location_t location, int n, const char *singular_gmsgid,
1100          const char *plural_gmsgid, ...)
1101 {
1102   diagnostic_info diagnostic;
1103   va_list ap;
1104
1105   va_start (ap, plural_gmsgid);
1106   diagnostic_set_info_translated (&diagnostic,
1107                                   ngettext (singular_gmsgid, plural_gmsgid, n),
1108                                   &ap, location, DK_ERROR);
1109   report_diagnostic (&diagnostic);
1110   va_end (ap);
1111 }
1112
1113 /* Same as ebove, but use location LOC instead of input_location.  */
1114 void
1115 error_at (location_t loc, const char *gmsgid, ...)
1116 {
1117   diagnostic_info diagnostic;
1118   va_list ap;
1119
1120   va_start (ap, gmsgid);
1121   diagnostic_set_info (&diagnostic, gmsgid, &ap, loc, DK_ERROR);
1122   report_diagnostic (&diagnostic);
1123   va_end (ap);
1124 }
1125
1126 /* "Sorry, not implemented."  Use for a language feature which is
1127    required by the relevant specification but not implemented by GCC.
1128    An object file will not be produced.  */
1129 void
1130 sorry (const char *gmsgid, ...)
1131 {
1132   diagnostic_info diagnostic;
1133   va_list ap;
1134
1135   va_start (ap, gmsgid);
1136   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_SORRY);
1137   report_diagnostic (&diagnostic);
1138   va_end (ap);
1139 }
1140
1141 /* Return true if an error or a "sorry" has been seen.  Various
1142    processing is disabled after errors.  */
1143 bool
1144 seen_error (void)
1145 {
1146   return errorcount || sorrycount;
1147 }
1148
1149 /* An error which is severe enough that we make no attempt to
1150    continue.  Do not use this for internal consistency checks; that's
1151    internal_error.  Use of this function should be rare.  */
1152 void
1153 fatal_error (const char *gmsgid, ...)
1154 {
1155   diagnostic_info diagnostic;
1156   va_list ap;
1157
1158   va_start (ap, gmsgid);
1159   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_FATAL);
1160   report_diagnostic (&diagnostic);
1161   va_end (ap);
1162
1163   gcc_unreachable ();
1164 }
1165
1166 /* An error which is severe enough that we make no attempt to
1167    continue.  Do not use this for internal consistency checks; that's
1168    internal_error.  Use of this function should be rare.  */
1169 void
1170 fatal_error (location_t loc, const char *gmsgid, ...)
1171 {
1172   diagnostic_info diagnostic;
1173   va_list ap;
1174
1175   va_start (ap, gmsgid);
1176   diagnostic_set_info (&diagnostic, gmsgid, &ap, loc, DK_FATAL);
1177   report_diagnostic (&diagnostic);
1178   va_end (ap);
1179
1180   gcc_unreachable ();
1181 }
1182
1183 /* An internal consistency check has failed.  We make no attempt to
1184    continue.  Note that unless there is debugging value to be had from
1185    a more specific message, or some other good reason, you should use
1186    abort () instead of calling this function directly.  */
1187 void
1188 internal_error (const char *gmsgid, ...)
1189 {
1190   diagnostic_info diagnostic;
1191   va_list ap;
1192
1193   va_start (ap, gmsgid);
1194   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ICE);
1195   report_diagnostic (&diagnostic);
1196   va_end (ap);
1197
1198   gcc_unreachable ();
1199 }
1200 \f
1201 /* Special case error functions.  Most are implemented in terms of the
1202    above, or should be.  */
1203
1204 /* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
1205    runs its second argument through gettext.  */
1206 void
1207 fnotice (FILE *file, const char *cmsgid, ...)
1208 {
1209   va_list ap;
1210
1211   va_start (ap, cmsgid);
1212   vfprintf (file, _(cmsgid), ap);
1213   va_end (ap);
1214 }
1215
1216 /* Inform the user that an error occurred while trying to report some
1217    other error.  This indicates catastrophic internal inconsistencies,
1218    so give up now.  But do try to flush out the previous error.
1219    This mustn't use internal_error, that will cause infinite recursion.  */
1220
1221 static void
1222 error_recursion (diagnostic_context *context)
1223 {
1224   diagnostic_info diagnostic;
1225
1226   if (context->lock < 3)
1227     pp_newline_and_flush (context->printer);
1228
1229   fnotice (stderr,
1230            "Internal compiler error: Error reporting routines re-entered.\n");
1231
1232   /* Call diagnostic_action_after_output to get the "please submit a bug
1233      report" message.  It only looks at the kind field of diagnostic_info.  */
1234   diagnostic.kind = DK_ICE;
1235   diagnostic_action_after_output (context, &diagnostic);
1236
1237   /* Do not use gcc_unreachable here; that goes through internal_error
1238      and therefore would cause infinite recursion.  */
1239   real_abort ();
1240 }
1241
1242 /* Report an internal compiler error in a friendly manner.  This is
1243    the function that gets called upon use of abort() in the source
1244    code generally, thanks to a special macro.  */
1245
1246 void
1247 fancy_abort (const char *file, int line, const char *function)
1248 {
1249   internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
1250 }
1251
1252 /* Really call the system 'abort'.  This has to go right at the end of
1253    this file, so that there are no functions after it that call abort
1254    and get the system abort instead of our macro.  */
1255 #undef abort
1256 static void
1257 real_abort (void)
1258 {
1259   abort ();
1260 }