1 /* messages.c - error reporter -
2 Copyright (C) 1987-2023 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 #include <limits.h>
22 #include <signal.h>
23
24 /* If the system doesn't provide strsignal, we get it defined in
25 libiberty but no declaration is supplied. Because, reasons. */
26 #if !defined (HAVE_STRSIGNAL) && !defined (strsignal)
27 extern const char *strsignal (int);
28 #endif
29
30 static void identify (const char *);
31 static void as_show_where (void);
32 static void as_warn_internal (const char *, unsigned int, char *);
33 static void as_bad_internal (const char *, unsigned int, char *);
34 static void signal_crash (int) ATTRIBUTE_NORETURN;
35
36 /* Despite the rest of the comments in this file, (FIXME-SOON),
37 here is the current scheme for error messages etc:
38
39 as_fatal() is used when gas is quite confused and
40 continuing the assembly is pointless. In this case we
41 exit immediately with error status.
42
43 as_bad() is used to mark errors that result in what we
44 presume to be a useless object file. Say, we ignored
45 something that might have been vital. If we see any of
46 these, assembly will continue to the end of the source,
47 no object file will be produced, and we will terminate
48 with error status. The new option, -Z, tells us to
49 produce an object file anyway but we still exit with
50 error status. The assumption here is that you don't want
51 this object file but we could be wrong.
52
53 as_warn() is used when we have an error from which we
54 have a plausible error recovery. eg, masking the top
55 bits of a constant that is longer than will fit in the
56 destination. In this case we will continue to assemble
57 the source, although we may have made a bad assumption,
58 and we will produce an object file and return normal exit
59 status (ie, no error). The new option -X tells us to
60 treat all as_warn() errors as as_bad() errors. That is,
61 no object file will be produced and we will exit with
62 error status. The idea here is that we don't kill an
63 entire make because of an error that we knew how to
64 correct. On the other hand, sometimes you might want to
65 stop the make at these points.
66
67 as_tsktsk() is used when we see a minor error for which
68 our error recovery action is almost certainly correct.
69 In this case, we print a message and then assembly
70 continues as though no error occurred.
71
72 as_abort () is used for logic failure (assert or abort, signal).
73 */
74
75 static void
76 identify (const char *file)
77 {
78 static int identified;
79
80 if (identified)
81 return;
82 identified++;
83
84 if (!file)
85 {
86 unsigned int x;
87 file = as_where (&x);
88 }
89
90 if (file)
91 fprintf (stderr, "%s: ", file);
92 fprintf (stderr, _("Assembler messages:\n"));
93 }
94
95 /* The number of warnings issued. */
96 static int warning_count;
97
98 int
99 had_warnings (void)
100 {
101 return warning_count;
102 }
103
104 /* Nonzero if we've hit a 'bad error', and should not write an obj file,
105 and exit with a nonzero error code. */
106
107 static int error_count;
108
109 int
110 had_errors (void)
111 {
112 return error_count;
113 }
114
115 /* Print the current location to stderr. */
116
117 static void
118 as_show_where (void)
119 {
120 const char *file;
121 unsigned int line;
122
123 file = as_where_top (&line);
124 identify (file);
125 if (file)
126 {
127 if (line != 0)
128 fprintf (stderr, "%s:%u: ", file, line);
129 else
130 fprintf (stderr, "%s: ", file);
131 }
132 }
133
134 /* Send to stderr a string as information, with location data passed in.
135 Note that for now this is not intended for general use. */
136
137 void
138 as_info_where (const char *file, unsigned int line, unsigned int indent,
139 const char *format, ...)
140 {
141 va_list args;
142 char buffer[2000];
143
144 va_start (args, format);
145 vsnprintf (buffer, sizeof (buffer), format, args);
146 va_end (args);
147 fprintf (stderr, "%s:%u: %*s%s%s\n",
148 file, line, (int)indent, "", _("Info: "), buffer);
149 }
150
151 /* Send to stderr a string as a warning, and locate warning
152 in input file(s).
153 Please only use this for when we have some recovery action.
154 Please explain in string (which may have '\n's) what recovery was
155 done. */
156
157 void
158 as_tsktsk (const char *format, ...)
159 {
160 va_list args;
161
162 as_show_where ();
163 va_start (args, format);
164 vfprintf (stderr, format, args);
165 va_end (args);
166 (void) putc ('\n', stderr);
167 as_report_context ();
168 }
169
170 /* The common portion of as_warn and as_warn_where. */
171
172 static void
173 as_warn_internal (const char *file, unsigned int line, char *buffer)
174 {
175 bool context = false;
176
177 ++warning_count;
178
179 if (file == NULL)
180 {
181 file = as_where_top (&line);
182 context = true;
183 }
184
185 identify (file);
186 if (file)
187 {
188 if (line != 0)
189 fprintf (stderr, "%s:%u: %s%s\n", file, line, _("Warning: "), buffer);
190 else
191 fprintf (stderr, "%s: %s%s\n", file, _("Warning: "), buffer);
192 }
193 else
194 fprintf (stderr, "%s%s\n", _("Warning: "), buffer);
195
196 if (context)
197 as_report_context ();
198
199 #ifndef NO_LISTING
200 listing_warning (buffer);
201 #endif
202 }
203
204 /* Send to stderr a string as a warning, and locate warning
205 in input file(s).
206 Please only use this for when we have some recovery action.
207 Please explain in string (which may have '\n's) what recovery was
208 done. */
209
210 void
211 as_warn (const char *format, ...)
212 {
213 va_list args;
214 char buffer[2000];
215
216 if (!flag_no_warnings)
217 {
218 va_start (args, format);
219 vsnprintf (buffer, sizeof (buffer), format, args);
220 va_end (args);
221 as_warn_internal ((char *) NULL, 0, buffer);
222 }
223 }
224
225 /* Like as_warn but the file name and line number are passed in.
226 Unfortunately, we have to repeat the function in order to handle
227 the varargs correctly and portably. */
228
229 void
230 as_warn_where (const char *file, unsigned int line, const char *format, ...)
231 {
232 va_list args;
233 char buffer[2000];
234
235 if (!flag_no_warnings)
236 {
237 va_start (args, format);
238 vsnprintf (buffer, sizeof (buffer), format, args);
239 va_end (args);
240 as_warn_internal (file, line, buffer);
241 }
242 }
243
244 /* The common portion of as_bad and as_bad_where. */
245
246 static void
247 as_bad_internal (const char *file, unsigned int line, char *buffer)
248 {
249 bool context = false;
250
251 ++error_count;
252
253 if (file == NULL)
254 {
255 file = as_where_top (&line);
256 context = true;
257 }
258
259 identify (file);
260 if (file)
261 {
262 if (line != 0)
263 fprintf (stderr, "%s:%u: %s%s\n", file, line, _("Error: "), buffer);
264 else
265 fprintf (stderr, "%s: %s%s\n", file, _("Error: "), buffer);
266 }
267 else
268 fprintf (stderr, "%s%s\n", _("Error: "), buffer);
269
270 if (context)
271 as_report_context ();
272
273 #ifndef NO_LISTING
274 listing_error (buffer);
275 #endif
276 }
277
278 /* Send to stderr a string as a warning, and locate warning in input
279 file(s). Please use when there is no recovery, but we want to
280 continue processing but not produce an object file.
281 Please explain in string (which may have '\n's) what recovery was
282 done. */
283
284 void
285 as_bad (const char *format, ...)
286 {
287 va_list args;
288 char buffer[2000];
289
290 va_start (args, format);
291 vsnprintf (buffer, sizeof (buffer), format, args);
292 va_end (args);
293
294 as_bad_internal ((char *) NULL, 0, buffer);
295 }
296
297 /* Like as_bad but the file name and line number are passed in.
298 Unfortunately, we have to repeat the function in order to handle
299 the varargs correctly and portably. */
300
301 void
302 as_bad_where (const char *file, unsigned int line, const char *format, ...)
303 {
304 va_list args;
305 char buffer[2000];
306
307 va_start (args, format);
308 vsnprintf (buffer, sizeof (buffer), format, args);
309 va_end (args);
310
311 as_bad_internal (file, line, buffer);
312 }
313
314 /* Send to stderr a string as a fatal message, and print location of
315 error in input file(s).
316 Please only use this for when we DON'T have some recovery action.
317 It xexit()s with a warning status. */
318
319 void
320 as_fatal (const char *format, ...)
321 {
322 va_list args;
323
324 as_show_where ();
325 va_start (args, format);
326 fprintf (stderr, _("Fatal error: "));
327 vfprintf (stderr, format, args);
328 (void) putc ('\n', stderr);
329 va_end (args);
330 as_report_context ();
331 /* Delete the output file, if it exists. This will prevent make from
332 thinking that a file was created and hence does not need rebuilding. */
333 if (out_file_name != NULL)
334 unlink_if_ordinary (out_file_name);
335 xexit (EXIT_FAILURE);
336 }
337
338 /* Indicate internal constency error.
339 Arguments: Filename, line number, optional function name.
340 FILENAME may be NULL, which we use for crash-via-signal. */
341
342 void
343 as_abort (const char *file, int line, const char *fn)
344 {
345 as_show_where ();
346
347 if (!file)
348 fprintf (stderr, _("Internal error (%s).\n"), fn ? fn : "unknown");
349 else if (fn)
350 fprintf (stderr, _("Internal error in %s at %s:%d.\n"), fn, file, line);
351 else
352 fprintf (stderr, _("Internal error at %s:%d.\n"), file, line);
353 as_report_context ();
354
355 fprintf (stderr, _("Please report this bug.\n"));
356
357 xexit (EXIT_FAILURE);
358 }
359
360 /* Handler for fatal signals, such as SIGSEGV. */
361
362 static void
363 signal_crash (int signo)
364 {
365 /* Reset, to prevent unbounded recursion. */
366 signal (signo, SIG_DFL);
367
368 as_abort (NULL, 0, strsignal (signo));
369 }
370
371 /* Register signal handlers, for less abrubt crashes. */
372
373 void
374 signal_init (void)
375 {
376 #ifdef SIGSEGV
377 signal (SIGSEGV, signal_crash);
378 #endif
379 #ifdef SIGILL
380 signal (SIGILL, signal_crash);
381 #endif
382 #ifdef SIGBUS
383 signal (SIGBUS, signal_crash);
384 #endif
385 #ifdef SIGABRT
386 signal (SIGABRT, signal_crash);
387 #endif
388 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
389 signal (SIGIOT, signal_crash);
390 #endif
391 #ifdef SIGFPE
392 signal (SIGFPE, signal_crash);
393 #endif
394 }
395
396 /* Support routines. */
397
398 #define HEX_MAX_THRESHOLD 1024
399 #define HEX_MIN_THRESHOLD -(HEX_MAX_THRESHOLD)
400
401 static void
402 as_internal_value_out_of_range (const char *prefix,
403 offsetT val,
404 offsetT min,
405 offsetT max,
406 const char *file,
407 unsigned line,
408 bool bad)
409 {
410 const char * err;
411
412 if (prefix == NULL)
413 prefix = "";
414
415 if (val >= min && val <= max)
416 {
417 addressT right = max & -max;
418
419 if (max <= 1)
420 abort ();
421
422 /* xgettext:c-format */
423 err = _("%s out of domain (%" PRId64
424 " is not a multiple of %" PRId64 ")");
425
426 if (bad)
427 as_bad_where (file, line, err, prefix, (int64_t) val, (int64_t) right);
428 else
429 as_warn_where (file, line, err, prefix, (int64_t) val, (int64_t) right);
430 }
431 else if ( val < HEX_MAX_THRESHOLD
432 && min < HEX_MAX_THRESHOLD
433 && max < HEX_MAX_THRESHOLD
434 && val > HEX_MIN_THRESHOLD
435 && min > HEX_MIN_THRESHOLD
436 && max > HEX_MIN_THRESHOLD)
437 {
438 /* xgettext:c-format. */
439 err = _("%s out of range (%" PRId64
440 " is not between %" PRId64 " and %" PRId64 ")");
441
442 if (bad)
443 as_bad_where (file, line, err, prefix,
444 (int64_t) val, (int64_t) min, (int64_t) max);
445 else
446 as_warn_where (file, line, err, prefix,
447 (int64_t) val, (int64_t) min, (int64_t) max);
448 }
449 else
450 {
451 /* xgettext:c-format. */
452 err = _("%s out of range (0x%" PRIx64
453 " is not between 0x%" PRIx64 " and 0x%" PRIx64 ")");
454
455 if (bad)
456 as_bad_where (file, line, err, prefix,
457 (int64_t) val, (int64_t) min, (int64_t) max);
458 else
459 as_warn_where (file, line, err, prefix,
460 (int64_t) val, (int64_t) min, (int64_t) max);
461 }
462 }
463
464 void
465 as_warn_value_out_of_range (const char *prefix,
466 offsetT value,
467 offsetT min,
468 offsetT max,
469 const char *file,
470 unsigned line)
471 {
472 as_internal_value_out_of_range (prefix, value, min, max, file, line, false);
473 }
474
475 void
476 as_bad_value_out_of_range (const char *prefix,
477 offsetT value,
478 offsetT min,
479 offsetT max,
480 const char *file,
481 unsigned line)
482 {
483 as_internal_value_out_of_range (prefix, value, min, max, file, line, true);
484 }