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