gcc/diagnostic.c

   1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
   2    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    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 2, 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 COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23
  24 /* This file implements the language independent aspect of diagnostic
  25    message module.  */
  26
  27 #include "config.h"
  28 #undef FLOAT /* This is for hpux. They should change hpux.  */
  29 #undef FFS  /* Some systems define this in param.h.  */
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include "tree.h"
  34 #include "version.h"
  35 #include "tm_p.h"
  36 #include "flags.h"
  37 #include "input.h"
  38 #include "toplev.h"
  39 #include "intl.h"
  40 #include "diagnostic.h"
  41 #include "langhooks.h"
  42 #include "langhooks-def.h"
  43 #include "opts.h"
  44
  45
  46 /* Prototypes.  */
  47 static char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
  48
  49 static void default_diagnostic_starter (diagnostic_context *,
  50                                         diagnostic_info *);
  51 static void default_diagnostic_finalizer (diagnostic_context *,
  52                                           diagnostic_info *);
  53
  54 static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
  55 static bool diagnostic_count_diagnostic (diagnostic_context *,
  56                                          diagnostic_info *);
  57 static void diagnostic_action_after_output (diagnostic_context *,
  58                                             diagnostic_info *);
  59 static void real_abort (void) ATTRIBUTE_NORETURN;
  60
  61 /* A diagnostic_context surrogate for stderr.  */
  62 static diagnostic_context global_diagnostic_context;
  63 diagnostic_context *global_dc = &global_diagnostic_context;
  64 \f
  65 /* Return a malloc'd string containing MSG formatted a la printf.  The
  66    caller is responsible for freeing the memory.  */
  67 static char *
  68 build_message_string (const char *msg, ...)
  69 {
  70   char *str;
  71   va_list ap;
  72
  73   va_start (ap, msg);
  74   vasprintf (&str, msg, ap);
  75   va_end (ap);
  76
  77   return str;
  78 }
  79
  80 /* Same as diagnostic_build_prefix, but only the source FILE is given.  */
  81 char *
  82 file_name_as_prefix (const char *f)
  83 {
  84   return build_message_string ("%s: ", f);
  85 }
  86
  87
  88 \f
  89 /* Initialize the diagnostic message outputting machinery.  */
  90 void
  91 diagnostic_initialize (diagnostic_context *context)
  92 {
  93   /* Allocate a basic pretty-printer.  Clients will replace this a
  94      much more elaborated pretty-printer if they wish.  */
  95   context->printer = xmalloc (sizeof (pretty_printer));
  96   pp_construct (context->printer, NULL, 0);
  97   /* By default, diagnostics are sent to stderr.  */
  98   context->printer->buffer->stream = stderr;
  99   /* By default, we emit prefixes once per message.  */
 100   context->printer->wrapping.rule = DIAGNOSTICS_SHOW_PREFIX_ONCE;
 101
 102   memset (context->diagnostic_count, 0, sizeof context->diagnostic_count);
 103   context->issue_warnings_are_errors_message = true;
 104   context->warning_as_error_requested = false;
 105   context->show_option_requested = false;
 106   context->abort_on_error = false;
 107   context->internal_error = NULL;
 108   diagnostic_starter (context) = default_diagnostic_starter;
 109   diagnostic_finalizer (context) = default_diagnostic_finalizer;
 110   context->last_module = 0;
 111   context->last_function = NULL;
 112   context->lock = 0;
 113 }
 114
 115 void
 116 diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid,
 117                      va_list *args, location_t location,
 118                      diagnostic_t kind)
 119 {
 120   diagnostic->message.err_no = errno;
 121   diagnostic->message.args_ptr = args;
 122   diagnostic->message.format_spec = _(gmsgid);
 123   diagnostic->location = location;
 124   diagnostic->kind = kind;
 125   diagnostic->option_index = 0;
 126 }
 127
 128 /* Return a malloc'd string describing a location.  The caller is
 129    responsible for freeing the memory.  */
 130 char *
 131 diagnostic_build_prefix (diagnostic_info *diagnostic)
 132 {
 133   static const char *const diagnostic_kind_text[] = {
 134 #define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
 135 #include "diagnostic.def"
 136 #undef DEFINE_DIAGNOSTIC_KIND
 137     "must-not-happen"
 138   };
 139   const char *text = _(diagnostic_kind_text[diagnostic->kind]);
 140   expanded_location s = expand_location (diagnostic->location);
 141   gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
 142
 143   return
 144     (s.file == NULL
 145      ? build_message_string ("%s: %s", progname, text)
 146 #ifdef USE_MAPPED_LOCATION
 147      : flag_show_column && s.column != 0
 148      ? build_message_string ("%s:%d:%d: %s", s.file, s.line, s.column, text)
 149 #endif
 150      : build_message_string ("%s:%d: %s", s.file, s.line, text));
 151 }
 152
 153 /* Count a diagnostic.  Return true if the message should be printed.  */
 154 static bool
 155 diagnostic_count_diagnostic (diagnostic_context *context,
 156                              diagnostic_info *diagnostic)
 157 {
 158   diagnostic_t kind = diagnostic->kind;
 159   switch (kind)
 160     {
 161     default:
 162       gcc_unreachable ();
 163
 164     case DK_ICE:
 165 #ifndef ENABLE_CHECKING
 166       /* When not checking, ICEs are converted to fatal errors when an
 167          error has already occurred.  This is counteracted by
 168          abort_on_error.  */
 169       if ((diagnostic_kind_count (context, DK_ERROR) > 0
 170            || diagnostic_kind_count (context, DK_SORRY) > 0)
 171           && !context->abort_on_error)
 172         {
 173           expanded_location s = expand_location (diagnostic->location);
 174           fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
 175                    s.file, s.line);
 176           exit (FATAL_EXIT_CODE);
 177         }
 178 #endif
 179       if (context->internal_error)
 180         (*context->internal_error) (diagnostic->message.format_spec,
 181                                     diagnostic->message.args_ptr);
 182       /* Fall through.  */
 183
 184     case DK_FATAL: case DK_SORRY:
 185     case DK_ANACHRONISM: case DK_NOTE:
 186       ++diagnostic_kind_count (context, kind);
 187       break;
 188
 189     case DK_WARNING:
 190       if (!diagnostic_report_warnings_p ())
 191         return false;
 192
 193       if (!context->warning_as_error_requested)
 194         {
 195           ++diagnostic_kind_count (context, DK_WARNING);
 196           break;
 197         }
 198       else if (context->issue_warnings_are_errors_message)
 199         {
 200           pp_verbatim (context->printer,
 201                        "%s: warnings being treated as errors\n", progname);
 202           context->issue_warnings_are_errors_message = false;
 203         }
 204
 205       /* And fall through.  */
 206     case DK_ERROR:
 207       ++diagnostic_kind_count (context, DK_ERROR);
 208       break;
 209     }
 210
 211   return true;
 212 }
 213
 214 /* Take any action which is expected to happen after the diagnostic
 215    is written out.  This function does not always return.  */
 216 static void
 217 diagnostic_action_after_output (diagnostic_context *context,
 218                                 diagnostic_info *diagnostic)
 219 {
 220   switch (diagnostic->kind)
 221     {
 222     case DK_DEBUG:
 223     case DK_NOTE:
 224     case DK_ANACHRONISM:
 225     case DK_WARNING:
 226       break;
 227
 228     case DK_ERROR:
 229     case DK_SORRY:
 230       if (context->abort_on_error)
 231         real_abort ();
 232       if (flag_fatal_errors)
 233         {
 234           fnotice (stderr, "compilation terminated due to -Wfatal-errors.\n");
 235           exit (FATAL_EXIT_CODE);
 236         }
 237       break;
 238
 239     case DK_ICE:
 240       if (context->abort_on_error)
 241         real_abort ();
 242
 243       fnotice (stderr, "Please submit a full bug report,\n"
 244                "with preprocessed source if appropriate.\n"
 245                "See %s for instructions.\n", bug_report_url);
 246       exit (FATAL_EXIT_CODE);
 247
 248     case DK_FATAL:
 249       if (context->abort_on_error)
 250         real_abort ();
 251
 252       fnotice (stderr, "compilation terminated.\n");
 253       exit (FATAL_EXIT_CODE);
 254
 255     default:
 256       gcc_unreachable ();
 257     }
 258 }
 259
 260 /* Prints out, if necessary, the name of the current function
 261    that caused an error.  Called from all error and warning functions.  */
 262 void
 263 diagnostic_report_current_function (diagnostic_context *context)
 264 {
 265   diagnostic_report_current_module (context);
 266   lang_hooks.print_error_function (context, input_filename);
 267 }
 268
 269 void
 270 diagnostic_report_current_module (diagnostic_context *context)
 271 {
 272   struct file_stack *p;
 273
 274   if (pp_needs_newline (context->printer))
 275     {
 276       pp_newline (context->printer);
 277       pp_needs_newline (context->printer) = false;
 278     }
 279
 280   p = input_file_stack;
 281   if (p && diagnostic_last_module_changed (context))
 282     {
 283       expanded_location xloc = expand_location (p->location);
 284       pp_verbatim (context->printer,
 285                    "In file included from %s:%d",
 286                    xloc.file, xloc.line);
 287       while ((p = p->next) != NULL)
 288         {
 289           xloc = expand_location (p->location);
 290           pp_verbatim (context->printer,
 291                        ",\n                 from %s:%d",
 292                        xloc.file, xloc.line);
 293         }
 294       pp_verbatim (context->printer, ":");
 295       diagnostic_set_last_module (context);
 296       pp_newline (context->printer);
 297     }
 298 }
 299
 300 static void
 301 default_diagnostic_starter (diagnostic_context *context,
 302                             diagnostic_info *diagnostic)
 303 {
 304   diagnostic_report_current_function (context);
 305   pp_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
 306 }
 307
 308 static void
 309 default_diagnostic_finalizer (diagnostic_context *context,
 310                               diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
 311 {
 312   pp_destroy_prefix (context->printer);
 313 }
 314
 315 /* Report a diagnostic message (an error or a warning) as specified by
 316    DC.  This function is *the* subroutine in terms of which front-ends
 317    should implement their specific diagnostic handling modules.  The
 318    front-end independent format specifiers are exactly those described
 319    in the documentation of output_format.  */
 320
 321 void
 322 diagnostic_report_diagnostic (diagnostic_context *context,
 323                               diagnostic_info *diagnostic)
 324 {
 325   if (context->lock > 0)
 326     {
 327       /* If we're reporting an ICE in the middle of some other error,
 328          try to flush out the previous error, then let this one
 329          through.  Don't do this more than once.  */
 330       if (diagnostic->kind == DK_ICE && context->lock == 1)
 331         pp_flush (context->printer);
 332       else
 333         error_recursion (context);
 334     }
 335
 336   if (diagnostic->option_index
 337       && ! option_enabled (diagnostic->option_index))
 338     return;
 339
 340   context->lock++;
 341
 342   if (diagnostic_count_diagnostic (context, diagnostic))
 343     {
 344       const char *saved_format_spec = diagnostic->message.format_spec;
 345
 346       if (context->show_option_requested && diagnostic->option_index)
 347         diagnostic->message.format_spec
 348           = ACONCAT ((diagnostic->message.format_spec,
 349                       " [", cl_options[diagnostic->option_index].opt_text, "]", NULL));
 350
 351       diagnostic->message.locus = &diagnostic->location;
 352       pp_format (context->printer, &diagnostic->message);
 353       (*diagnostic_starter (context)) (context, diagnostic);
 354       pp_output_formatted_text (context->printer);
 355       (*diagnostic_finalizer (context)) (context, diagnostic);
 356       pp_flush (context->printer);
 357       diagnostic_action_after_output (context, diagnostic);
 358       diagnostic->message.format_spec = saved_format_spec;
 359     }
 360
 361   context->lock--;
 362 }
 363
 364 /* Given a partial pathname as input, return another pathname that
 365    shares no directory elements with the pathname of __FILE__.  This
 366    is used by fancy_abort() to print `Internal compiler error in expr.c'
 367    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
 368
 369 const char *
 370 trim_filename (const char *name)
 371 {
 372   static const char this_file[] = __FILE__;
 373   const char *p = name, *q = this_file;
 374
 375   /* First skip any "../" in each filename.  This allows us to give a proper
 376      reference to a file in a subdirectory.  */
 377   while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
 378     p += 3;
 379
 380   while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
 381     q += 3;
 382
 383   /* Now skip any parts the two filenames have in common.  */
 384   while (*p == *q && *p != 0 && *q != 0)
 385     p++, q++;
 386
 387   /* Now go backwards until the previous directory separator.  */
 388   while (p > name && !IS_DIR_SEPARATOR (p[-1]))
 389     p--;
 390
 391   return p;
 392 }
 393 \f
 394 /* Standard error reporting routines in increasing order of severity.
 395    All of these take arguments like printf.  */
 396
 397 /* Text to be emitted verbatim to the error message stream; this
 398    produces no prefix and disables line-wrapping.  Use rarely.  */
 399 void
 400 verbatim (const char *gmsgid, ...)
 401 {
 402   text_info text;
 403   va_list ap;
 404
 405   va_start (ap, gmsgid);
 406   text.err_no = errno;
 407   text.args_ptr = &ap;
 408   text.format_spec = _(gmsgid);
 409   text.locus = NULL;
 410   pp_format_verbatim (global_dc->printer, &text);
 411   pp_flush (global_dc->printer);
 412   va_end (ap);
 413 }
 414
 415 /* An informative note.  Use this for additional details on an error
 416    message.  */
 417 void
 418 inform (const char *gmsgid, ...)
 419 {
 420   diagnostic_info diagnostic;
 421   va_list ap;
 422
 423   va_start (ap, gmsgid);
 424   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_NOTE);
 425   report_diagnostic (&diagnostic);
 426   va_end (ap);
 427 }
 428
 429 /* A warning.  Use this for code which is correct according to the
 430    relevant language specification but is likely to be buggy anyway.  */
 431 void
 432 warning (int opt, const char *gmsgid, ...)
 433 {
 434   diagnostic_info diagnostic;
 435   va_list ap;
 436
 437   va_start (ap, gmsgid);
 438   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING);
 439   diagnostic.option_index = opt;
 440
 441   report_diagnostic (&diagnostic);
 442   va_end (ap);
 443 }
 444
 445 void
 446 warning0 (const char *gmsgid, ...)
 447 {
 448   diagnostic_info diagnostic;
 449   va_list ap;
 450
 451   va_start (ap, gmsgid);
 452   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING);
 453   report_diagnostic (&diagnostic);
 454   va_end (ap);
 455 }
 456
 457 /* A "pedantic" warning: issues a warning unless -pedantic-errors was
 458    given on the command line, in which case it issues an error.  Use
 459    this for diagnostics required by the relevant language standard,
 460    if you have chosen not to make them errors.
 461
 462    Note that these diagnostics are issued independent of the setting
 463    of the -pedantic command-line switch.  To get a warning enabled
 464    only with that switch, write "if (pedantic) pedwarn (...);"  */
 465 void
 466 pedwarn (const char *gmsgid, ...)
 467 {
 468   diagnostic_info diagnostic;
 469   va_list ap;
 470
 471   va_start (ap, gmsgid);
 472   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location,
 473                        pedantic_error_kind ());
 474   report_diagnostic (&diagnostic);
 475   va_end (ap);
 476 }
 477
 478 /* A hard error: the code is definitely ill-formed, and an object file
 479    will not be produced.  */
 480 void
 481 error (const char *gmsgid, ...)
 482 {
 483   diagnostic_info diagnostic;
 484   va_list ap;
 485
 486   va_start (ap, gmsgid);
 487   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ERROR);
 488   report_diagnostic (&diagnostic);
 489   va_end (ap);
 490 }
 491
 492 /* "Sorry, not implemented."  Use for a language feature which is
 493    required by the relevant specification but not implemented by GCC.
 494    An object file will not be produced.  */
 495 void
 496 sorry (const char *gmsgid, ...)
 497 {
 498   diagnostic_info diagnostic;
 499   va_list ap;
 500
 501   va_start (ap, gmsgid);
 502   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_SORRY);
 503   report_diagnostic (&diagnostic);
 504   va_end (ap);
 505 }
 506
 507 /* An error which is severe enough that we make no attempt to
 508    continue.  Do not use this for internal consistency checks; that's
 509    internal_error.  Use of this function should be rare.  */
 510 void
 511 fatal_error (const char *gmsgid, ...)
 512 {
 513   diagnostic_info diagnostic;
 514   va_list ap;
 515
 516   va_start (ap, gmsgid);
 517   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_FATAL);
 518   report_diagnostic (&diagnostic);
 519   va_end (ap);
 520
 521   gcc_unreachable ();
 522 }
 523
 524 /* An internal consistency check has failed.  We make no attempt to
 525    continue.  Note that unless there is debugging value to be had from
 526    a more specific message, or some other good reason, you should use
 527    abort () instead of calling this function directly.  */
 528 void
 529 internal_error (const char *gmsgid, ...)
 530 {
 531   diagnostic_info diagnostic;
 532   va_list ap;
 533
 534   va_start (ap, gmsgid);
 535   diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ICE);
 536   report_diagnostic (&diagnostic);
 537   va_end (ap);
 538
 539   gcc_unreachable ();
 540 }
 541 \f
 542 /* Special case error functions.  Most are implemented in terms of the
 543    above, or should be.  */
 544
 545 /* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
 546    runs its second argument through gettext.  */
 547 void
 548 fnotice (FILE *file, const char *cmsgid, ...)
 549 {
 550   va_list ap;
 551
 552   va_start (ap, cmsgid);
 553   vfprintf (file, _(cmsgid), ap);
 554   va_end (ap);
 555 }
 556
 557 /* Inform the user that an error occurred while trying to report some
 558    other error.  This indicates catastrophic internal inconsistencies,
 559    so give up now.  But do try to flush out the previous error.
 560    This mustn't use internal_error, that will cause infinite recursion.  */
 561
 562 static void
 563 error_recursion (diagnostic_context *context)
 564 {
 565   diagnostic_info diagnostic;
 566
 567   if (context->lock < 3)
 568     pp_flush (context->printer);
 569
 570   fnotice (stderr,
 571            "Internal compiler error: Error reporting routines re-entered.\n");
 572
 573   /* Call diagnostic_action_after_output to get the "please submit a bug
 574      report" message.  It only looks at the kind field of diagnostic_info.  */
 575   diagnostic.kind = DK_ICE;
 576   diagnostic_action_after_output (context, &diagnostic);
 577
 578   /* Do not use gcc_unreachable here; that goes through internal_error
 579      and therefore would cause infinite recursion.  */
 580   real_abort ();
 581 }
 582
 583 /* Report an internal compiler error in a friendly manner.  This is
 584    the function that gets called upon use of abort() in the source
 585    code generally, thanks to a special macro.  */
 586
 587 void
 588 fancy_abort (const char *file, int line, const char *function)
 589 {
 590   internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
 591 }
 592
 593 /* Really call the system 'abort'.  This has to go right at the end of
 594    this file, so that there are no functions after it that call abort
 595    and get the system abort instead of our macro.  */
 596 #undef abort
 597 static void
 598 real_abort (void)
 599 {
 600   abort ();
 601 }