gcc/diagnostic.c

   1 /* Language-independent diagnostic subroutines for the GNU Compiler Collection
   2    Copyright (C) 1999, 2000, 2001, 2002, 2003 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 2, 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 COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 /* This file implements the language independent aspect of diagnostic
  24    message module.  */
  25
  26 #include "config.h"
  27 #undef FLOAT /* This is for hpux. They should change hpux.  */
  28 #undef FFS  /* Some systems define this in param.h.  */
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "tree.h"
  33 #include "tm_p.h"
  34 #include "flags.h"
  35 #include "input.h"
  36 #include "toplev.h"
  37 #include "intl.h"
  38 #include "diagnostic.h"
  39 #include "langhooks.h"
  40 #include "langhooks-def.h"
  41
  42
  43 /* Prototypes.  */
  44 static char *build_message_string (const char *, ...) ATTRIBUTE_PRINTF_1;
  45
  46 static void default_diagnostic_starter (diagnostic_context *,
  47                                         diagnostic_info *);
  48 static void default_diagnostic_finalizer (diagnostic_context *,
  49                                           diagnostic_info *);
  50
  51 static void error_recursion (diagnostic_context *) ATTRIBUTE_NORETURN;
  52 static bool text_specifies_location (text_info *, location_t *);
  53 static bool diagnostic_count_diagnostic (diagnostic_context *,
  54                                          diagnostic_info *);
  55 static void diagnostic_action_after_output (diagnostic_context *,
  56                                             diagnostic_info *);
  57 static void real_abort (void) ATTRIBUTE_NORETURN;
  58
  59 extern int rtl_dump_and_exit;
  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->warnings_are_errors_message = warnings_are_errors;
 111   context->abort_on_error = false;
 112   context->internal_error = NULL;
 113   diagnostic_starter (context) = default_diagnostic_starter;
 114   diagnostic_finalizer (context) = default_diagnostic_finalizer;
 115   context->last_module = 0;
 116   context->last_function = NULL;
 117   context->lock = 0;
 118   context->x_data = NULL;
 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 == '%' && *++p == 'H')
 134     {
 135       *locus = *va_arg (*text->args_ptr, location_t *);
 136       text->format_spec = p + 1;
 137       return true;
 138     }
 139
 140   return false;
 141 }
 142
 143 void
 144 diagnostic_set_info (diagnostic_info *diagnostic, const char *msgid,
 145                      va_list *args, location_t location,
 146                      diagnostic_t kind)
 147 {
 148   diagnostic->message.err_no = errno;
 149   diagnostic->message.args_ptr = args;
 150   diagnostic->message.format_spec = _(msgid);
 151   /* If the diagnostic message doesn't specify a location,
 152      use LOCATION.  */
 153   if (!text_specifies_location (&diagnostic->message, &diagnostic->location))
 154     diagnostic->location = location;
 155   diagnostic->kind = kind;
 156 }
 157
 158 /* Return a malloc'd string describing a location.  The caller is
 159    responsible for freeing the memory.  */
 160 char *
 161 diagnostic_build_prefix (diagnostic_info *diagnostic)
 162 {
 163   static const char *const diagnostic_kind_text[] = {
 164 #define DEFINE_DIAGNOSTIC_KIND(K, T) (T),
 165 #include "diagnostic.def"
 166 #undef DEFINE_DIAGNOSTIC_KIND
 167     "must-not-happen"
 168   };
 169    if (diagnostic->kind >= DK_LAST_DIAGNOSTIC_KIND)
 170      abort();
 171
 172   return diagnostic->location.file
 173     ? build_message_string ("%s:%d: %s",
 174                             diagnostic->location.file,
 175                             diagnostic->location.line,
 176                             _(diagnostic_kind_text[diagnostic->kind]))
 177     : build_message_string ("%s: %s", progname,
 178                             _(diagnostic_kind_text[diagnostic->kind]));
 179 }
 180
 181 /* Count a diagnostic.  Return true if the message should be printed.  */
 182 static bool
 183 diagnostic_count_diagnostic (diagnostic_context *context,
 184                              diagnostic_info *diagnostic)
 185 {
 186   diagnostic_t kind = diagnostic->kind;
 187   switch (kind)
 188     {
 189     default:
 190       abort();
 191       break;
 192
 193     case DK_ICE:
 194 #ifndef ENABLE_CHECKING
 195       /* When not checking, ICEs are converted to fatal errors when an
 196          error has already occurred.  This is counteracted by
 197          abort_on_error.  */
 198       if ((diagnostic_kind_count (context, DK_ERROR) > 0
 199            || diagnostic_kind_count (context, DK_SORRY) > 0)
 200           && !context->abort_on_error)
 201         {
 202           fnotice (stderr, "%s:%d: confused by earlier errors, bailing out\n",
 203                    diagnostic->location.file, diagnostic->location.line);
 204           exit (FATAL_EXIT_CODE);
 205         }
 206 #endif
 207       if (context->internal_error)
 208         (*context->internal_error) (diagnostic->message.format_spec,
 209                                     diagnostic->message.args_ptr);
 210       /* Fall through.  */
 211
 212     case DK_FATAL: case DK_SORRY:
 213     case DK_ANACHRONISM: case DK_NOTE:
 214       ++diagnostic_kind_count (context, kind);
 215       break;
 216
 217     case DK_WARNING:
 218       if (!diagnostic_report_warnings_p ())
 219         return false;
 220
 221       if (!warnings_are_errors)
 222         {
 223           ++diagnostic_kind_count (context, DK_WARNING);
 224           break;
 225         }
 226
 227       if (context->warnings_are_errors_message)
 228         {
 229           pp_verbatim (context->printer,
 230                        "%s: warnings being treated as errors\n", progname);
 231           context->warnings_are_errors_message = false;
 232         }
 233
 234       /* And fall through.  */
 235     case DK_ERROR:
 236       ++diagnostic_kind_count (context, DK_ERROR);
 237       break;
 238     }
 239
 240   return true;
 241 }
 242
 243 /* Take any action which is expected to happen after the diagnostic
 244    is written out.  This function does not always return.  */
 245 static void
 246 diagnostic_action_after_output (diagnostic_context *context,
 247                                 diagnostic_info *diagnostic)
 248 {
 249   switch (diagnostic->kind)
 250     {
 251     case DK_DEBUG:
 252     case DK_NOTE:
 253     case DK_ANACHRONISM:
 254     case DK_WARNING:
 255       break;
 256
 257     case DK_ERROR:
 258     case DK_SORRY:
 259       if (context->abort_on_error)
 260         real_abort ();
 261       break;
 262
 263     case DK_ICE:
 264       if (context->abort_on_error)
 265         real_abort ();
 266
 267       fnotice (stderr, bug_report_request, bug_report_url);
 268       exit (FATAL_EXIT_CODE);
 269
 270     case DK_FATAL:
 271       if (context->abort_on_error)
 272         real_abort ();
 273
 274       fnotice (stderr, "compilation terminated.\n");
 275       exit (FATAL_EXIT_CODE);
 276
 277     default:
 278       real_abort ();
 279     }
 280 }
 281
 282 /* Called when the start of a function definition is parsed,
 283    this function prints on stderr the name of the function.  */
 284 void
 285 announce_function (tree decl)
 286 {
 287   if (!quiet_flag)
 288     {
 289       if (rtl_dump_and_exit)
 290         verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl)));
 291       else
 292         verbatim (" %s", (*lang_hooks.decl_printable_name) (decl, 2));
 293       fflush (stderr);
 294       global_dc->printer->need_newline = true;
 295       diagnostic_set_last_function (global_dc);
 296     }
 297 }
 298
 299 /* The default function to print out name of current function that caused
 300    an error.  */
 301 void
 302 lhd_print_error_function (diagnostic_context *context, const char *file)
 303 {
 304   if (diagnostic_last_function_changed (context))
 305     {
 306       const char *old_prefix = context->printer->prefix;
 307       char *new_prefix = file ? build_message_string ("%s: ", file) : NULL;
 308
 309       pp_set_prefix (context->printer, new_prefix);
 310
 311       if (current_function_decl == NULL)
 312         pp_string (context->printer, _("At top level:"));
 313       else
 314         {
 315           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 316             pp_printf
 317               (context->printer, "In member function `%s':",
 318                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
 319           else
 320             pp_printf
 321               (context->printer, "In function `%s':",
 322                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
 323         }
 324       pp_newline (context->printer);
 325
 326       diagnostic_set_last_function (context);
 327       pp_flush (context->printer);
 328       context->printer->prefix = old_prefix;
 329       free ((char*) new_prefix);
 330     }
 331 }
 332
 333 /* Prints out, if necessary, the name of the current function
 334   that caused an error.  Called from all error and warning functions.
 335   We ignore the FILE parameter, as it cannot be relied upon.  */
 336
 337 void
 338 diagnostic_report_current_function (diagnostic_context *context)
 339 {
 340   diagnostic_report_current_module (context);
 341   (*lang_hooks.print_error_function) (context, input_filename);
 342 }
 343
 344 void
 345 diagnostic_report_current_module (diagnostic_context *context)
 346 {
 347   struct file_stack *p;
 348
 349   if (pp_needs_newline (context->printer))
 350     {
 351       pp_newline (context->printer);
 352       pp_needs_newline (context->printer) = false;
 353     }
 354
 355   if (input_file_stack && diagnostic_last_module_changed (context))
 356     {
 357       p = input_file_stack;
 358       pp_verbatim (context->printer,
 359                    "In file included from %s:%d",
 360                    p->location.file, p->location.line);
 361       while ((p = p->next) != NULL)
 362         pp_verbatim (context->printer,
 363                      ",\n                 from %s:%d",
 364                      p->location.file, p->location.line);
 365       pp_verbatim (context->printer, ":\n");
 366       diagnostic_set_last_module (context);
 367     }
 368 }
 369
 370 static void
 371 default_diagnostic_starter (diagnostic_context *context,
 372                             diagnostic_info *diagnostic)
 373 {
 374   diagnostic_report_current_function (context);
 375   pp_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
 376 }
 377
 378 static void
 379 default_diagnostic_finalizer (diagnostic_context *context,
 380                               diagnostic_info *diagnostic __attribute__((unused)))
 381 {
 382   pp_destroy_prefix (context->printer);
 383 }
 384
 385 /* Report a diagnostic message (an error or a warning) as specified by
 386    DC.  This function is *the* subroutine in terms of which front-ends
 387    should implement their specific diagnostic handling modules.  The
 388    front-end independent format specifiers are exactly those described
 389    in the documentation of output_format.  */
 390
 391 void
 392 diagnostic_report_diagnostic (diagnostic_context *context,
 393                               diagnostic_info *diagnostic)
 394 {
 395   if (context->lock++ && diagnostic->kind < DK_SORRY)
 396     error_recursion (context);
 397
 398   if (diagnostic_count_diagnostic (context, diagnostic))
 399     {
 400       (*diagnostic_starter (context)) (context, diagnostic);
 401       pp_format_text (context->printer, &diagnostic->message);
 402       (*diagnostic_finalizer (context)) (context, diagnostic);
 403       pp_flush (context->printer);
 404       diagnostic_action_after_output (context, diagnostic);
 405     }
 406
 407   context->lock--;
 408 }
 409
 410 /* Given a partial pathname as input, return another pathname that
 411    shares no directory elements with the pathname of __FILE__.  This
 412    is used by fancy_abort() to print `Internal compiler error in expr.c'
 413    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
 414
 415 const char *
 416 trim_filename (const char *name)
 417 {
 418   static const char this_file[] = __FILE__;
 419   const char *p = name, *q = this_file;
 420
 421   /* First skip any "../" in each filename.  This allows us to give a proper
 422      reference to a file in a subdirectory.  */
 423   while (p[0] == '.' && p[1] == '.'
 424          && (p[2] == DIR_SEPARATOR
 425 #ifdef DIR_SEPARATOR_2
 426              || p[2] == DIR_SEPARATOR_2
 427 #endif
 428              ))
 429     p += 3;
 430
 431   while (q[0] == '.' && q[1] == '.'
 432          && (q[2] == DIR_SEPARATOR
 433 #ifdef DIR_SEPARATOR_2
 434              || p[2] == DIR_SEPARATOR_2
 435 #endif
 436              ))
 437     q += 3;
 438
 439   /* Now skip any parts the two filenames have in common.  */
 440   while (*p == *q && *p != 0 && *q != 0)
 441     p++, q++;
 442
 443   /* Now go backwards until the previous directory separator.  */
 444   while (p > name && p[-1] != DIR_SEPARATOR
 445 #ifdef DIR_SEPARATOR_2
 446          && p[-1] != DIR_SEPARATOR_2
 447 #endif
 448          )
 449     p--;
 450
 451   return p;
 452 }
 453 \f
 454 /* Standard error reporting routines in increasing order of severity.
 455    All of these take arguments like printf.  */
 456
 457 /* Text to be emitted verbatim to the error message stream; this
 458    produces no prefix and disables line-wrapping.  Use rarely.  */
 459 void
 460 verbatim (const char *msgid, ...)
 461 {
 462   text_info text;
 463   va_list ap;
 464
 465   va_start (ap, msgid);
 466   text.err_no = errno;
 467   text.args_ptr = &ap;
 468   text.format_spec = _(msgid);
 469   pp_format_verbatim (global_dc->printer, &text);
 470   pp_flush (global_dc->printer);
 471   va_end (ap);
 472 }
 473
 474 /* An informative note.  Use this for additional details on an error
 475    message.  */
 476 void
 477 inform (const char *msgid, ...)
 478 {
 479   diagnostic_info diagnostic;
 480   va_list ap;
 481
 482   va_start (ap, msgid);
 483   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_NOTE);
 484   report_diagnostic (&diagnostic);
 485   va_end (ap);
 486 }
 487
 488 /* A warning.  Use this for code which is correct according to the
 489    relevant language specification but is likely to be buggy anyway.  */
 490 void
 491 warning (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_WARNING);
 498   report_diagnostic (&diagnostic);
 499   va_end (ap);
 500 }
 501
 502 /* A "pedantic" warning: issues a warning unless -pedantic-errors was
 503    given on the command line, in which case it issues an error.  Use
 504    this for diagnostics required by the relevant language standard,
 505    if you have chosen not to make them errors.
 506
 507    Note that these diagnostics are issued independent of the setting
 508    of the -pedantic command-line switch.  To get a warning enabled
 509    only with that switch, write "if (pedantic) pedwarn (...);"  */
 510 void
 511 pedwarn (const char *msgid, ...)
 512 {
 513   diagnostic_info diagnostic;
 514   va_list ap;
 515
 516   va_start (ap, msgid);
 517   diagnostic_set_info (&diagnostic, msgid, &ap, input_location,
 518                        pedantic_error_kind ());
 519   report_diagnostic (&diagnostic);
 520   va_end (ap);
 521 }
 522
 523 /* A hard error: the code is definitely ill-formed, and an object file
 524    will not be produced.  */
 525 void
 526 error (const char *msgid, ...)
 527 {
 528   diagnostic_info diagnostic;
 529   va_list ap;
 530
 531   va_start (ap, msgid);
 532   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_ERROR);
 533   report_diagnostic (&diagnostic);
 534   va_end (ap);
 535 }
 536
 537 /* "Sorry, not implemented."  Use for a language feature which is
 538    required by the relevant specification but not implemented by GCC.
 539    An object file will not be produced.  */
 540 void
 541 sorry (const char *msgid, ...)
 542 {
 543   diagnostic_info diagnostic;
 544   va_list ap;
 545
 546   va_start (ap, msgid);
 547   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_SORRY);
 548   report_diagnostic (&diagnostic);
 549   va_end (ap);
 550 }
 551
 552 /* An error which is severe enough that we make no attempt to
 553    continue.  Do not use this for internal consistency checks; that's
 554    internal_error.  Use of this function should be rare.  */
 555 void
 556 fatal_error (const char *msgid, ...)
 557 {
 558   diagnostic_info diagnostic;
 559   va_list ap;
 560
 561   va_start (ap, msgid);
 562   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_FATAL);
 563   report_diagnostic (&diagnostic);
 564   va_end (ap);
 565
 566   /* NOTREACHED */
 567   real_abort ();
 568 }
 569
 570 /* An internal consistency check has failed.  We make no attempt to
 571    continue.  Note that unless there is debugging value to be had from
 572    a more specific message, or some other good reason, you should use
 573    abort () instead of calling this function directly.  */
 574 void
 575 internal_error (const char *msgid, ...)
 576 {
 577   diagnostic_info diagnostic;
 578   va_list ap;
 579
 580   va_start (ap, msgid);
 581   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_ICE);
 582   report_diagnostic (&diagnostic);
 583   va_end (ap);
 584
 585   /* NOTREACHED */
 586   real_abort ();
 587 }
 588 \f
 589 /* Special case error functions.  Most are implemented in terms of the
 590    above, or should be.  */
 591
 592 /* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
 593    runs its second argument through gettext.  */
 594 void
 595 fnotice (FILE *file, const char *msgid, ...)
 596 {
 597   va_list ap;
 598
 599   va_start (ap, msgid);
 600   vfprintf (file, _(msgid), ap);
 601   va_end (ap);
 602 }
 603
 604 /* Warn about a use of an identifier which was marked deprecated.  */
 605 void
 606 warn_deprecated_use (tree node)
 607 {
 608   if (node == 0 || !warn_deprecated_decl)
 609     return;
 610
 611   if (DECL_P (node))
 612     warning ("`%s' is deprecated (declared at %s:%d)",
 613              IDENTIFIER_POINTER (DECL_NAME (node)),
 614              DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
 615   else if (TYPE_P (node))
 616     {
 617       const char *what = NULL;
 618       tree decl = TYPE_STUB_DECL (node);
 619
 620       if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 621         what = IDENTIFIER_POINTER (TYPE_NAME (node));
 622       else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 623                && DECL_NAME (TYPE_NAME (node)))
 624         what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
 625
 626       if (what)
 627         {
 628           if (decl)
 629             warning ("`%s' is deprecated (declared at %s:%d)", what,
 630                      DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
 631           else
 632             warning ("`%s' is deprecated", what);
 633         }
 634       else if (decl)
 635         warning ("type is deprecated (declared at %s:%d)",
 636                  DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
 637       else
 638         warning ("type is deprecated");
 639     }
 640 }
 641
 642 /* Inform the user that an error occurred while trying to report some
 643    other error.  This indicates catastrophic internal inconsistencies,
 644    so give up now.  But do try to flush out the previous error.
 645    This mustn't use internal_error, that will cause infinite recursion.  */
 646
 647 static void
 648 error_recursion (diagnostic_context *context)
 649 {
 650   if (context->lock < 3)
 651     pp_flush (context->printer);
 652
 653   fnotice (stderr,
 654            "Internal compiler error: Error reporting routines re-entered.\n");
 655   fnotice (stderr, bug_report_request, bug_report_url);
 656   exit (FATAL_EXIT_CODE);
 657 }
 658
 659 /* Report an internal compiler error in a friendly manner.  This is
 660    the function that gets called upon use of abort() in the source
 661    code generally, thanks to a special macro.  */
 662
 663 void
 664 fancy_abort (const char *file, int line, const char *function)
 665 {
 666   internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
 667 }
 668
 669 /* Really call the system 'abort'.  This has to go right at the end of
 670    this file, so that there are no functions after it that call abort
 671    and get the system abort instead of our macro.  */
 672 #undef abort
 673 static void
 674 real_abort (void)
 675 {
 676   abort ();
 677 }