1 /* messages.c - error reporter - 2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001, 3 2003, 2004, 2005 4 Free Software Foundation, Inc. 5 This file is part of GAS, the GNU Assembler. 6 7 GAS is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GAS is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GAS; see the file COPYING. If not, write to the Free 19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22 #include "as.h" 23 24 static void identify (char *); 25 static void as_show_where (void); 26 static void as_warn_internal (char *, unsigned int, char *); 27 static void as_bad_internal (char *, unsigned int, char *); 28 29 /* Despite the rest of the comments in this file, (FIXME-SOON), 30 here is the current scheme for error messages etc: 31 32 as_fatal() is used when gas is quite confused and 33 continuing the assembly is pointless. In this case we 34 exit immediately with error status. 35 36 as_bad() is used to mark errors that result in what we 37 presume to be a useless object file. Say, we ignored 38 something that might have been vital. If we see any of 39 these, assembly will continue to the end of the source, 40 no object file will be produced, and we will terminate 41 with error status. The new option, -Z, tells us to 42 produce an object file anyway but we still exit with 43 error status. The assumption here is that you don't want 44 this object file but we could be wrong. 45 46 as_warn() is used when we have an error from which we 47 have a plausible error recovery. eg, masking the top 48 bits of a constant that is longer than will fit in the 49 destination. In this case we will continue to assemble 50 the source, although we may have made a bad assumption, 51 and we will produce an object file and return normal exit 52 status (ie, no error). The new option -X tells us to 53 treat all as_warn() errors as as_bad() errors. That is, 54 no object file will be produced and we will exit with 55 error status. The idea here is that we don't kill an 56 entire make because of an error that we knew how to 57 correct. On the other hand, sometimes you might want to 58 stop the make at these points. 59 60 as_tsktsk() is used when we see a minor error for which 61 our error recovery action is almost certainly correct. 62 In this case, we print a message and then assembly 63 continues as though no error occurred. */ 64 65 static void 66 identify (char *file) 67 { 68 static int identified; 69 70 if (identified) 71 return; 72 identified++; 73 74 if (!file) 75 { 76 unsigned int x; 77 as_where (&file, &x); 78 } 79 80 if (file) 81 fprintf (stderr, "%s: ", file); 82 fprintf (stderr, _("Assembler messages:\n")); 83 } 84 85 /* The number of warnings issued. */ 86 static int warning_count; 87 88 int 89 had_warnings (void) 90 { 91 return warning_count; 92 } 93 94 /* Nonzero if we've hit a 'bad error', and should not write an obj file, 95 and exit with a nonzero error code. */ 96 97 static int error_count; 98 99 int 100 had_errors (void) 101 { 102 return error_count; 103 } 104 105 /* Print the current location to stderr. */ 106 107 static void 108 as_show_where (void) 109 { 110 char *file; 111 unsigned int line; 112 113 as_where (&file, &line); 114 identify (file); 115 if (file) 116 fprintf (stderr, "%s:%u: ", file, line); 117 } 118 119 /* Like perror(3), but with more info. */ 120 121 void 122 as_perror (const char *gripe, /* Unpunctuated error theme. */ 123 const char *filename) 124 { 125 const char *errtxt; 126 int saved_errno = errno; 127 128 as_show_where (); 129 fprintf (stderr, gripe, filename); 130 errno = saved_errno; 131 errtxt = bfd_errmsg (bfd_get_error ()); 132 fprintf (stderr, ": %s\n", errtxt); 133 errno = 0; 134 bfd_set_error (bfd_error_no_error); 135 } 136 137 /* Send to stderr a string as a warning, and locate warning 138 in input file(s). 139 Please only use this for when we have some recovery action. 140 Please explain in string (which may have '\n's) what recovery was 141 done. */ 142 143 #ifdef USE_STDARG 144 void 145 as_tsktsk (const char *format, ...) 146 { 147 va_list args; 148 149 as_show_where (); 150 va_start (args, format); 151 vfprintf (stderr, format, args); 152 va_end (args); 153 (void) putc ('\n', stderr); 154 } 155 #else 156 void 157 as_tsktsk (format, va_alist) 158 const char *format; 159 va_dcl 160 { 161 va_list args; 162 163 as_show_where (); 164 va_start (args); 165 vfprintf (stderr, format, args); 166 va_end (args); 167 (void) putc ('\n', stderr); 168 } 169 #endif /* not NO_STDARG */ 170 171 /* The common portion of as_warn and as_warn_where. */ 172 173 static void 174 as_warn_internal (char *file, unsigned int line, char *buffer) 175 { 176 ++warning_count; 177 178 if (file == NULL) 179 as_where (&file, &line); 180 181 identify (file); 182 if (file) 183 fprintf (stderr, "%s:%u: ", file, line); 184 fprintf (stderr, _("Warning: ")); 185 fputs (buffer, stderr); 186 (void) putc ('\n', stderr); 187 #ifndef NO_LISTING 188 listing_warning (buffer); 189 #endif 190 } 191 192 /* Send to stderr a string as a warning, and locate warning 193 in input file(s). 194 Please only use this for when we have some recovery action. 195 Please explain in string (which may have '\n's) what recovery was 196 done. */ 197 198 #ifdef USE_STDARG 199 void 200 as_warn (const char *format, ...) 201 { 202 va_list args; 203 char buffer[2000]; 204 205 if (!flag_no_warnings) 206 { 207 va_start (args, format); 208 vsnprintf (buffer, sizeof (buffer), format, args); 209 va_end (args); 210 as_warn_internal ((char *) NULL, 0, buffer); 211 } 212 } 213 #else 214 void 215 as_warn (format, va_alist) 216 const char *format; 217 va_dcl 218 { 219 va_list args; 220 char buffer[2000]; 221 222 if (!flag_no_warnings) 223 { 224 va_start (args); 225 vsnprintf (buffer, sizeof (buffer), format, args); 226 va_end (args); 227 as_warn_internal ((char *) NULL, 0, buffer); 228 } 229 } 230 #endif /* not NO_STDARG */ 231 232 /* Like as_bad but the file name and line number are passed in. 233 Unfortunately, we have to repeat the function in order to handle 234 the varargs correctly and portably. */ 235 236 #ifdef USE_STDARG 237 void 238 as_warn_where (char *file, unsigned int line, const char *format, ...) 239 { 240 va_list args; 241 char buffer[2000]; 242 243 if (!flag_no_warnings) 244 { 245 va_start (args, format); 246 vsnprintf (buffer, sizeof (buffer), format, args); 247 va_end (args); 248 as_warn_internal (file, line, buffer); 249 } 250 } 251 #else 252 void 253 as_warn_where (file, line, format, va_alist) 254 char *file; 255 unsigned int line; 256 const char *format; 257 va_dcl 258 { 259 va_list args; 260 char buffer[2000]; 261 262 if (!flag_no_warnings) 263 { 264 va_start (args); 265 vsnprintf (buffer, sizeof (buffer), format, args); 266 va_end (args); 267 as_warn_internal (file, line, buffer); 268 } 269 } 270 #endif /* not NO_STDARG */ 271 272 /* The common portion of as_bad and as_bad_where. */ 273 274 static void 275 as_bad_internal (char *file, unsigned int line, char *buffer) 276 { 277 ++error_count; 278 279 if (file == NULL) 280 as_where (&file, &line); 281 282 identify (file); 283 if (file) 284 fprintf (stderr, "%s:%u: ", file, line); 285 fprintf (stderr, _("Error: ")); 286 fputs (buffer, stderr); 287 (void) putc ('\n', stderr); 288 #ifndef NO_LISTING 289 listing_error (buffer); 290 #endif 291 } 292 293 /* Send to stderr a string as a warning, and locate warning in input 294 file(s). Please us when there is no recovery, but we want to 295 continue processing but not produce an object file. 296 Please explain in string (which may have '\n's) what recovery was 297 done. */ 298 299 #ifdef USE_STDARG 300 void 301 as_bad (const char *format, ...) 302 { 303 va_list args; 304 char buffer[2000]; 305 306 va_start (args, format); 307 vsnprintf (buffer, sizeof (buffer), format, args); 308 va_end (args); 309 310 as_bad_internal ((char *) NULL, 0, buffer); 311 } 312 313 #else 314 void 315 as_bad (format, va_alist) 316 const char *format; 317 va_dcl 318 { 319 va_list args; 320 char buffer[2000]; 321 322 va_start (args); 323 vsnprintf (buffer, sizeof (buffer), format, args); 324 va_end (args); 325 326 as_bad_internal ((char *) NULL, 0, buffer); 327 } 328 #endif /* not NO_STDARG */ 329 330 /* Like as_bad but the file name and line number are passed in. 331 Unfortunately, we have to repeat the function in order to handle 332 the varargs correctly and portably. */ 333 334 #ifdef USE_STDARG 335 void 336 as_bad_where (char *file, unsigned int line, const char *format, ...) 337 { 338 va_list args; 339 char buffer[2000]; 340 341 va_start (args, format); 342 vsnprintf (buffer, sizeof (buffer), format, args); 343 va_end (args); 344 345 as_bad_internal (file, line, buffer); 346 } 347 348 #else 349 void 350 as_bad_where (file, line, format, va_alist) 351 char *file; 352 unsigned int line; 353 const char *format; 354 va_dcl 355 { 356 va_list args; 357 char buffer[2000]; 358 359 va_start (args); 360 vsnprintf (buffer, sizeof (buffer), format, args); 361 va_end (args); 362 363 as_bad_internal (file, line, buffer); 364 } 365 #endif /* not NO_STDARG */ 366 367 /* Send to stderr a string as a fatal message, and print location of 368 error in input file(s). 369 Please only use this for when we DON'T have some recovery action. 370 It xexit()s with a warning status. */ 371 372 #ifdef USE_STDARG 373 void 374 as_fatal (const char *format, ...) 375 { 376 va_list args; 377 378 as_show_where (); 379 va_start (args, format); 380 fprintf (stderr, _("Fatal error: ")); 381 vfprintf (stderr, format, args); 382 (void) putc ('\n', stderr); 383 va_end (args); 384 /* Delete the output file, if it exists. This will prevent make from 385 thinking that a file was created and hence does not need rebuilding. */ 386 if (out_file_name != NULL) 387 unlink_if_ordinary (out_file_name); 388 xexit (EXIT_FAILURE); 389 } 390 #else 391 void 392 as_fatal (format, va_alist) 393 char *format; 394 va_dcl 395 { 396 va_list args; 397 398 as_show_where (); 399 va_start (args); 400 fprintf (stderr, _("Fatal error: ")); 401 vfprintf (stderr, format, args); 402 (void) putc ('\n', stderr); 403 va_end (args); 404 xexit (EXIT_FAILURE); 405 } 406 #endif /* not NO_STDARG */ 407 408 /* Indicate assertion failure. 409 Arguments: Filename, line number, optional function name. */ 410 411 void 412 as_assert (const char *file, int line, const char *fn) 413 { 414 as_show_where (); 415 fprintf (stderr, _("Internal error!\n")); 416 if (fn) 417 fprintf (stderr, _("Assertion failure in %s at %s line %d.\n"), 418 fn, file, line); 419 else 420 fprintf (stderr, _("Assertion failure at %s line %d.\n"), file, line); 421 fprintf (stderr, _("Please report this bug.\n")); 422 xexit (EXIT_FAILURE); 423 } 424 425 /* as_abort: Print a friendly message saying how totally hosed we are, 426 and exit without producing a core file. */ 427 428 void 429 as_abort (const char *file, int line, const char *fn) 430 { 431 as_show_where (); 432 if (fn) 433 fprintf (stderr, _("Internal error, aborting at %s line %d in %s\n"), 434 file, line, fn); 435 else 436 fprintf (stderr, _("Internal error, aborting at %s line %d\n"), 437 file, line); 438 fprintf (stderr, _("Please report this bug.\n")); 439 xexit (EXIT_FAILURE); 440 } 441 442 /* Support routines. */ 443 444 void 445 sprint_value (char *buf, valueT val) 446 { 447 if (sizeof (val) <= sizeof (long)) 448 { 449 sprintf (buf, "%ld", (long) val); 450 return; 451 } 452 if (sizeof (val) <= sizeof (bfd_vma)) 453 { 454 sprintf_vma (buf, val); 455 return; 456 } 457 abort (); 458 } 459 460 #define HEX_MAX_THRESHOLD 1024 461 #define HEX_MIN_THRESHOLD -(HEX_MAX_THRESHOLD) 462 463 static void 464 as_internal_value_out_of_range (char * prefix, 465 offsetT val, 466 offsetT min, 467 offsetT max, 468 char * file, 469 unsigned line, 470 int bad) 471 { 472 const char * err; 473 474 if (prefix == NULL) 475 prefix = ""; 476 477 if ( val < HEX_MAX_THRESHOLD 478 && min < HEX_MAX_THRESHOLD 479 && max < HEX_MAX_THRESHOLD 480 && val > HEX_MIN_THRESHOLD 481 && min > HEX_MIN_THRESHOLD 482 && max > HEX_MIN_THRESHOLD) 483 { 484 /* xgettext:c-format */ 485 err = _("%s out of range (%d is not between %d and %d)"); 486 487 if (bad) 488 as_bad_where (file, line, err, 489 prefix, (int) val, (int) min, (int) max); 490 else 491 as_warn_where (file, line, err, 492 prefix, (int) val, (int) min, (int) max); 493 } 494 else 495 { 496 char val_buf [sizeof (val) * 3 + 2]; 497 char min_buf [sizeof (val) * 3 + 2]; 498 char max_buf [sizeof (val) * 3 + 2]; 499 500 if (sizeof (val) > sizeof (bfd_vma)) 501 abort (); 502 503 sprintf_vma (val_buf, val); 504 sprintf_vma (min_buf, min); 505 sprintf_vma (max_buf, max); 506 507 /* xgettext:c-format. */ 508 err = _("%s out of range (0x%s is not between 0x%s and 0x%s)"); 509 510 if (bad) 511 as_bad_where (file, line, err, prefix, val_buf, min_buf, max_buf); 512 else 513 as_warn_where (file, line, err, prefix, val_buf, min_buf, max_buf); 514 } 515 } 516 517 void 518 as_warn_value_out_of_range (char * prefix, 519 offsetT value, 520 offsetT min, 521 offsetT max, 522 char * file, 523 unsigned line) 524 { 525 as_internal_value_out_of_range (prefix, value, min, max, file, line, 0); 526 } 527 528 void 529 as_bad_value_out_of_range (char * prefix, 530 offsetT value, 531 offsetT min, 532 offsetT max, 533 char * file, 534 unsigned line) 535 { 536 as_internal_value_out_of_range (prefix, value, min, max, file, line, 1); 537 } 538