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 /* The default function to print out name of current function that caused
 283    an error.  */
 284 void
 285 lhd_print_error_function (diagnostic_context *context, const char *file)
 286 {
 287   if (diagnostic_last_function_changed (context))
 288     {
 289       const char *old_prefix = context->printer->prefix;
 290       char *new_prefix = file ? build_message_string ("%s: ", file) : NULL;
 291
 292       pp_set_prefix (context->printer, new_prefix);
 293
 294       if (current_function_decl == NULL)
 295         pp_string (context->printer, _("At top level:"));
 296       else
 297         {
 298           if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
 299             pp_printf
 300               (context->printer, "In member function `%s':",
 301                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
 302           else
 303             pp_printf
 304               (context->printer, "In function `%s':",
 305                (*lang_hooks.decl_printable_name) (current_function_decl, 2));
 306         }
 307       pp_newline (context->printer);
 308
 309       diagnostic_set_last_function (context);
 310       pp_flush (context->printer);
 311       context->printer->prefix = old_prefix;
 312       free ((char*) new_prefix);
 313     }
 314 }
 315
 316 /* Prints out, if necessary, the name of the current function
 317   that caused an error.  Called from all error and warning functions.
 318   We ignore the FILE parameter, as it cannot be relied upon.  */
 319
 320 void
 321 diagnostic_report_current_function (diagnostic_context *context)
 322 {
 323   diagnostic_report_current_module (context);
 324   (*lang_hooks.print_error_function) (context, input_filename);
 325 }
 326
 327 void
 328 diagnostic_report_current_module (diagnostic_context *context)
 329 {
 330   struct file_stack *p;
 331
 332   if (pp_needs_newline (context->printer))
 333     {
 334       pp_newline (context->printer);
 335       pp_needs_newline (context->printer) = false;
 336     }
 337
 338   if (input_file_stack && diagnostic_last_module_changed (context))
 339     {
 340       p = input_file_stack;
 341       pp_verbatim (context->printer,
 342                    "In file included from %s:%d",
 343                    p->location.file, p->location.line);
 344       while ((p = p->next) != NULL)
 345         pp_verbatim (context->printer,
 346                      ",\n                 from %s:%d",
 347                      p->location.file, p->location.line);
 348       pp_verbatim (context->printer, ":\n");
 349       diagnostic_set_last_module (context);
 350     }
 351 }
 352
 353 static void
 354 default_diagnostic_starter (diagnostic_context *context,
 355                             diagnostic_info *diagnostic)
 356 {
 357   diagnostic_report_current_function (context);
 358   pp_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
 359 }
 360
 361 static void
 362 default_diagnostic_finalizer (diagnostic_context *context,
 363                               diagnostic_info *diagnostic __attribute__((unused)))
 364 {
 365   pp_destroy_prefix (context->printer);
 366 }
 367
 368 /* Report a diagnostic message (an error or a warning) as specified by
 369    DC.  This function is *the* subroutine in terms of which front-ends
 370    should implement their specific diagnostic handling modules.  The
 371    front-end independent format specifiers are exactly those described
 372    in the documentation of output_format.  */
 373
 374 void
 375 diagnostic_report_diagnostic (diagnostic_context *context,
 376                               diagnostic_info *diagnostic)
 377 {
 378   if (context->lock++ && diagnostic->kind < DK_SORRY)
 379     error_recursion (context);
 380
 381   if (diagnostic_count_diagnostic (context, diagnostic))
 382     {
 383       (*diagnostic_starter (context)) (context, diagnostic);
 384       pp_format_text (context->printer, &diagnostic->message);
 385       (*diagnostic_finalizer (context)) (context, diagnostic);
 386       pp_flush (context->printer);
 387       diagnostic_action_after_output (context, diagnostic);
 388     }
 389
 390   context->lock--;
 391 }
 392
 393 /* Given a partial pathname as input, return another pathname that
 394    shares no directory elements with the pathname of __FILE__.  This
 395    is used by fancy_abort() to print `Internal compiler error in expr.c'
 396    instead of `Internal compiler error in ../../GCC/gcc/expr.c'.  */
 397
 398 const char *
 399 trim_filename (const char *name)
 400 {
 401   static const char this_file[] = __FILE__;
 402   const char *p = name, *q = this_file;
 403
 404   /* First skip any "../" in each filename.  This allows us to give a proper
 405      reference to a file in a subdirectory.  */
 406   while (p[0] == '.' && p[1] == '.'
 407          && (p[2] == DIR_SEPARATOR
 408 #ifdef DIR_SEPARATOR_2
 409              || p[2] == DIR_SEPARATOR_2
 410 #endif
 411              ))
 412     p += 3;
 413
 414   while (q[0] == '.' && q[1] == '.'
 415          && (q[2] == DIR_SEPARATOR
 416 #ifdef DIR_SEPARATOR_2
 417              || p[2] == DIR_SEPARATOR_2
 418 #endif
 419              ))
 420     q += 3;
 421
 422   /* Now skip any parts the two filenames have in common.  */
 423   while (*p == *q && *p != 0 && *q != 0)
 424     p++, q++;
 425
 426   /* Now go backwards until the previous directory separator.  */
 427   while (p > name && p[-1] != DIR_SEPARATOR
 428 #ifdef DIR_SEPARATOR_2
 429          && p[-1] != DIR_SEPARATOR_2
 430 #endif
 431          )
 432     p--;
 433
 434   return p;
 435 }
 436 \f
 437 /* Standard error reporting routines in increasing order of severity.
 438    All of these take arguments like printf.  */
 439
 440 /* Text to be emitted verbatim to the error message stream; this
 441    produces no prefix and disables line-wrapping.  Use rarely.  */
 442 void
 443 verbatim (const char *msgid, ...)
 444 {
 445   text_info text;
 446   va_list ap;
 447
 448   va_start (ap, msgid);
 449   text.err_no = errno;
 450   text.args_ptr = &ap;
 451   text.format_spec = _(msgid);
 452   pp_format_verbatim (global_dc->printer, &text);
 453   pp_flush (global_dc->printer);
 454   va_end (ap);
 455 }
 456
 457 /* An informative note.  Use this for additional details on an error
 458    message.  */
 459 void
 460 inform (const char *msgid, ...)
 461 {
 462   diagnostic_info diagnostic;
 463   va_list ap;
 464
 465   va_start (ap, msgid);
 466   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_NOTE);
 467   report_diagnostic (&diagnostic);
 468   va_end (ap);
 469 }
 470
 471 /* A warning.  Use this for code which is correct according to the
 472    relevant language specification but is likely to be buggy anyway.  */
 473 void
 474 warning (const char *msgid, ...)
 475 {
 476   diagnostic_info diagnostic;
 477   va_list ap;
 478
 479   va_start (ap, msgid);
 480   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_WARNING);
 481   report_diagnostic (&diagnostic);
 482   va_end (ap);
 483 }
 484
 485 /* A "pedantic" warning: issues a warning unless -pedantic-errors was
 486    given on the command line, in which case it issues an error.  Use
 487    this for diagnostics required by the relevant language standard,
 488    if you have chosen not to make them errors.
 489
 490    Note that these diagnostics are issued independent of the setting
 491    of the -pedantic command-line switch.  To get a warning enabled
 492    only with that switch, write "if (pedantic) pedwarn (...);"  */
 493 void
 494 pedwarn (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,
 501                        pedantic_error_kind ());
 502   report_diagnostic (&diagnostic);
 503   va_end (ap);
 504 }
 505
 506 /* A hard error: the code is definitely ill-formed, and an object file
 507    will not be produced.  */
 508 void
 509 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_ERROR);
 516   report_diagnostic (&diagnostic);
 517   va_end (ap);
 518 }
 519
 520 /* "Sorry, not implemented."  Use for a language feature which is
 521    required by the relevant specification but not implemented by GCC.
 522    An object file will not be produced.  */
 523 void
 524 sorry (const char *msgid, ...)
 525 {
 526   diagnostic_info diagnostic;
 527   va_list ap;
 528
 529   va_start (ap, msgid);
 530   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_SORRY);
 531   report_diagnostic (&diagnostic);
 532   va_end (ap);
 533 }
 534
 535 /* An error which is severe enough that we make no attempt to
 536    continue.  Do not use this for internal consistency checks; that's
 537    internal_error.  Use of this function should be rare.  */
 538 void
 539 fatal_error (const char *msgid, ...)
 540 {
 541   diagnostic_info diagnostic;
 542   va_list ap;
 543
 544   va_start (ap, msgid);
 545   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_FATAL);
 546   report_diagnostic (&diagnostic);
 547   va_end (ap);
 548
 549   /* NOTREACHED */
 550   real_abort ();
 551 }
 552
 553 /* An internal consistency check has failed.  We make no attempt to
 554    continue.  Note that unless there is debugging value to be had from
 555    a more specific message, or some other good reason, you should use
 556    abort () instead of calling this function directly.  */
 557 void
 558 internal_error (const char *msgid, ...)
 559 {
 560   diagnostic_info diagnostic;
 561   va_list ap;
 562
 563   va_start (ap, msgid);
 564   diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_ICE);
 565   report_diagnostic (&diagnostic);
 566   va_end (ap);
 567
 568   /* NOTREACHED */
 569   real_abort ();
 570 }
 571 \f
 572 /* Special case error functions.  Most are implemented in terms of the
 573    above, or should be.  */
 574
 575 /* Print a diagnostic MSGID on FILE.  This is just fprintf, except it
 576    runs its second argument through gettext.  */
 577 void
 578 fnotice (FILE *file, const char *msgid, ...)
 579 {
 580   va_list ap;
 581
 582   va_start (ap, msgid);
 583   vfprintf (file, _(msgid), ap);
 584   va_end (ap);
 585 }
 586
 587 /* Warn about a use of an identifier which was marked deprecated.  */
 588 void
 589 warn_deprecated_use (tree node)
 590 {
 591   if (node == 0 || !warn_deprecated_decl)
 592     return;
 593
 594   if (DECL_P (node))
 595     warning ("`%s' is deprecated (declared at %s:%d)",
 596              IDENTIFIER_POINTER (DECL_NAME (node)),
 597              DECL_SOURCE_FILE (node), DECL_SOURCE_LINE (node));
 598   else if (TYPE_P (node))
 599     {
 600       const char *what = NULL;
 601       tree decl = TYPE_STUB_DECL (node);
 602
 603       if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 604         what = IDENTIFIER_POINTER (TYPE_NAME (node));
 605       else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 606                && DECL_NAME (TYPE_NAME (node)))
 607         what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node)));
 608
 609       if (what)
 610         {
 611           if (decl)
 612             warning ("`%s' is deprecated (declared at %s:%d)", what,
 613                      DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
 614           else
 615             warning ("`%s' is deprecated", what);
 616         }
 617       else if (decl)
 618         warning ("type is deprecated (declared at %s:%d)",
 619                  DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
 620       else
 621         warning ("type is deprecated");
 622     }
 623 }
 624
 625 /* Inform the user that an error occurred while trying to report some
 626    other error.  This indicates catastrophic internal inconsistencies,
 627    so give up now.  But do try to flush out the previous error.
 628    This mustn't use internal_error, that will cause infinite recursion.  */
 629
 630 static void
 631 error_recursion (diagnostic_context *context)
 632 {
 633   if (context->lock < 3)
 634     pp_flush (context->printer);
 635
 636   fnotice (stderr,
 637            "Internal compiler error: Error reporting routines re-entered.\n");
 638   fnotice (stderr, bug_report_request, bug_report_url);
 639   exit (FATAL_EXIT_CODE);
 640 }
 641
 642 /* Report an internal compiler error in a friendly manner.  This is
 643    the function that gets called upon use of abort() in the source
 644    code generally, thanks to a special macro.  */
 645
 646 void
 647 fancy_abort (const char *file, int line, const char *function)
 648 {
 649   internal_error ("in %s, at %s:%d", function, trim_filename (file), line);
 650 }
 651
 652 /* Really call the system 'abort'.  This has to go right at the end of
 653    this file, so that there are no functions after it that call abort
 654    and get the system abort instead of our macro.  */
 655 #undef abort
 656 static void
 657 real_abort (void)
 658 {
 659   abort ();
 660 }