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, 59 Temple Place - Suite 330, Boston, MA
  21 02111-1307, 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->prefixing_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 *msgid,
 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 = _(msgid);
 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, ":\n");
 295       diagnostic_set_last_module (context);
 296     }
 297 }
 298
 299 static void
 300 default_diagnostic_starter (diagnostic_context *context,
 301                             diagnostic_info *diagnostic)
 302 {
 303   diagnostic_report_current_function (context);
 304   pp_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
 305 }
 306
 307 static void
 308 default_diagnostic_finalizer (diagnostic_context *context,
 309                               diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
 310 {
 311   pp_destroy_prefix (context->printer);
 312 }
 313
 314 /* Report a diagnostic message (an error or a warning) as specified by
 315    DC.  This function is *the* subroutine in terms of which front-ends
 316    should implement their specific diagnostic handling modules.  The
 317    front-end independent format specifiers are exactly those described
 318    in the documentation of output_format.  */
 319
 320 void
 321 diagnostic_report_diagnostic (diagnostic_context *context,
 322                               diagnostic_info *diagnostic)
 323 {
 324   if (context->lock > 0)
 325     {
 326       /* If we're reporting an ICE in the middle of some other error,
 327          try to flush out the previous error, then let this one
 328          through.  Don't do this more than once.  */
 329       if (diagnostic->kind == DK_ICE && context->lock == 1)
 330         pp_flush (context->printer);
 331       else
 332         error_recursion (context);
 333     }
 334
 335   if (diagnostic->option_index
 336       && ! option_enabled (diagnostic->option_index))
 337     return;
 338
 339   context->lock++;
 340
 341   if (diagnostic_count_diagnostic (context, diagnostic))
 342     {
 343       const char *saved_format_spec = diagnostic->message.format_spec;
 344
 345       if (context->show_option_requested && diagnostic->option_index)
 346         diagnostic->message.format_spec
 347           = ACONCAT ((diagnostic->message.format_spec,
 348                       " [", cl_options[diagnostic->option_index].opt_text, "]", NULL));
 349
 350       pp_prepare_to_format (context->printer, &diagnostic->message,
 351                             &diagnostic->location);
 352       (*diagnostic_starter (context)) (context, diagnostic);
 353       pp_format_text (context->printer, &diagnostic->message);
 354       (*diagnostic_finalizer (context)) (context, diagnostic);
 355       pp_flush (context->printer);
 356       diagnostic_action_after_output (context, diagnostic);
 357       diagnostic->message.format_spec = saved_format_spec;
 358     }
 359
 360   context->lock--;
 361 }
 362
 363 /* Given a partial pathname as input, return another pathname that
 364    shares no directory elements with the pathname of __FILE__.  This
 365    is used by fancy_abort() to print `Internal compiler error in expr.c'
 366    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
 367
 368 const char *
 369 trim_filename (const char *name)
 370 {
 371   static const char this_file[] = __FILE__;
 372   const char *p = name, *q = this_file;
 373
 374   /* First skip any "../" in each filename.  This allows us to give a proper
 375      reference to a file in a subdirectory.  */
 376   while (p[0] == '.' && p[1] == '.' && IS_DIR_SEPARATOR (p[2]))
 377     p += 3;
 378
 379   while (q[0] == '.' && q[1] == '.' && IS_DIR_SEPARATOR (q[2]))
 380     q += 3;
 381
 382   /* Now skip any parts the two filenames have in common.  */
 383   while (*p == *q && *p != 0 && *q != 0)
 384     p++, q++;
 385
 386   /* Now go backwards until the previous directory separator.  */
 387   while (p > name && !IS_DIR_SEPARATOR (p[-1]))
 388     p--;
 389
 390   return p;
 391 }
 392 \f
 393 /* Standard error reporting routines in increasing order of severity.
 394    All of these take arguments like printf.  */
 395
 396 /* Text to be emitted verbatim to the error message stream; this
 397    produces no prefix and disables line-wrapping.  Use rarely.  */
 398 void
 399 verbatim (const char *msgid, ...)
 400 {
 401   text_info text;
 402   va_list ap;
 403
 404   va_start (ap, msgid);
 405   text.err_no = errno;
 406   text.args_ptr = &ap;
 407   text.format_spec = _(msgid);
 408   pp_format_verbatim (global_dc->printer, &text);
 409   pp_flush (global_dc->printer);
 410   va_end (ap);
 411 }
 412
 413 /* An informative note.  Use this for additional details on an error
 414    message.  */
 415 void
 416 inform (const char *msgid, ...)
 417 {
 418   diagnostic_info diagnostic;
 419   va_list ap;
 420
 421   va_start (ap, msgid);
 422   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_NOTE);
 423   report_diagnostic (&diagnostic);
 424   va_end (ap);
 425 }
 426
 427 /* A warning.  Use this for code which is correct according to the
 428    relevant language specification but is likely to be buggy anyway.  */
 429 void
 430 warning (int opt, const char *msgid, ...)
 431 {
 432   diagnostic_info diagnostic;
 433   va_list ap;
 434
 435   va_start (ap, msgid);
 436   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_WARNING);
 437   diagnostic.option_index = opt;
 438
 439   report_diagnostic (&diagnostic);
 440   va_end (ap);
 441 }
 442
 443 void
 444 warning0 (const char *msgid, ...)
 445 {
 446   diagnostic_info diagnostic;
 447   va_list ap;
 448
 449   va_start (ap, msgid);
 450   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_WARNING);
 451   report_diagnostic (&diagnostic);
 452   va_end (ap);
 453 }
 454
 455 /* A "pedantic" warning: issues a warning unless -pedantic-errors was
 456    given on the command line, in which case it issues an error.  Use
 457    this for diagnostics required by the relevant language standard,
 458    if you have chosen not to make them errors.
 459
 460    Note that these diagnostics are issued independent of the setting
 461    of the -pedantic command-line switch.  To get a warning enabled
 462    only with that switch, write "if (pedantic) pedwarn (...);"  */
 463 void
 464 pedwarn (const char *msgid, ...)
 465 {
 466   diagnostic_info diagnostic;
 467   va_list ap;
 468
 469   va_start (ap, msgid);
 470   diagnostic_set_info (&diagnostic, msgid, &ap, input_location,
 471                        pedantic_error_kind ());
 472   report_diagnostic (&diagnostic);
 473   va_end (ap);
 474 }
 475
 476 /* A hard error: the code is definitely ill-formed, and an object file
 477    will not be produced.  */
 478 void
 479 error (const char *msgid, ...)
 480 {
 481   diagnostic_info diagnostic;
 482   va_list ap;
 483
 484   va_start (ap, msgid);
 485   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_ERROR);
 486   report_diagnostic (&diagnostic);
 487   va_end (ap);
 488 }
 489
 490 /* "Sorry, not implemented."  Use for a language feature which is
 491    required by the relevant specification but not implemented by GCC.
 492    An object file will not be produced.  */
 493 void
 494 sorry (const char *msgid, ...)
 495 {
 496   diagnostic_info diagnostic;
 497   va_list ap;
 498
 499   va_start (ap, msgid);
 500   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_SORRY);
 501   report_diagnostic (&diagnostic);
 502   va_end (ap);
 503 }
 504
 505 /* An error which is severe enough that we make no attempt to
 506    continue.  Do not use this for internal consistency checks; that's
 507    internal_error.  Use of this function should be rare.  */
 508 void
 509 fatal_error (const char *msgid, ...)
 510 {
 511   diagnostic_info diagnostic;
 512   va_list ap;
 513
 514   va_start (ap, msgid);
 515   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_FATAL);
 516   report_diagnostic (&diagnostic);
 517   va_end (ap);
 518
 519   gcc_unreachable ();
 520 }
 521
 522 /* An internal consistency check has failed.  We make no attempt to
 523    continue.  Note that unless there is debugging value to be had from
 524    a more specific message, or some other good reason, you should use
 525    abort () instead of calling this function directly.  */
 526 void
 527 internal_error (const char *msgid, ...)
 528 {
 529   diagnostic_info diagnostic;
 530   va_list ap;
 531
 532   va_start (ap, msgid);
 533   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_ICE);
 534   report_diagnostic (&diagnostic);
 535   va_end (ap);
 536
 537   gcc_unreachable ();
 538 }
 539 \f
 540 /* Special case error functions.  Most are implemented in terms of the
 541    above, or should be.  */
 542
 543 /* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
 544    runs its second argument through gettext.  */
 545 void
 546 fnotice (FILE *file, const char *msgid, ...)
 547 {
 548   va_list ap;
 549
 550   va_start (ap, msgid);
 551   vfprintf (file, _(msgid), ap);
 552   va_end (ap);
 553 }
 554
 555 /* Inform the user that an error occurred while trying to report some
 556    other error.  This indicates catastrophic internal inconsistencies,
 557    so give up now.  But do try to flush out the previous error.
 558    This mustn't use internal_error, that will cause infinite recursion.  */
 559
 560 static void
 561 error_recursion (diagnostic_context *context)
 562 {
 563   diagnostic_info diagnostic;
 564
 565   if (context->lock < 3)
 566     pp_flush (context->printer);
 567
 568   fnotice (stderr,
 569            "Internal compiler error: Error reporting routines re-entered.\n");
 570
 571   /* Call diagnostic_action_after_output to get the "please submit a bug
 572      report" message.  It only looks at the kind field of diagnostic_info.  */
 573   diagnostic.kind = DK_ICE;
 574   diagnostic_action_after_output (context, &diagnostic);
 575
 576   /* Do not use gcc_unreachable here; that goes through internal_error
 577      and therefore would cause infinite recursion.  */
 578   real_abort ();
 579 }
 580
 581 /* Report an internal compiler error in a friendly manner.  This is
 582    the function that gets called upon use of abort() in the source
 583    code generally, thanks to a special macro.  */
 584
 585 void
 586 fancy_abort (const char *file, int line, const char *function)
 587 {
 588   internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
 589 }
 590
 591 /* Really call the system 'abort'.  This has to go right at the end of
 592    this file, so that there are no functions after it that call abort
 593    and get the system abort instead of our macro.  */
 594 #undef abort
 595 static void
 596 real_abort (void)
 597 {
 598   abort ();
 599 }