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