gcc/diagnostic.c

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