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