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