ld:
[binutils.git] / gas / messages.c
blob9ea1bce26dcdfb0c8dca15cdfc02a783e14dc5cc
1 /* messages.c - error reporter -
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001,
3 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
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 3, or (at your option)
10 any later version.
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.
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. */
22 #include "as.h"
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 *);
29 /* Despite the rest of the comments in this file, (FIXME-SOON),
30 here is the current scheme for error messages etc:
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.
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.
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.
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. */
65 static void
66 identify (char *file)
68 static int identified;
70 if (identified)
71 return;
72 identified++;
74 if (!file)
76 unsigned int x;
77 as_where (&file, &x);
80 if (file)
81 fprintf (stderr, "%s: ", file);
82 fprintf (stderr, _("Assembler messages:\n"));
85 /* The number of warnings issued. */
86 static int warning_count;
88 int
89 had_warnings (void)
91 return warning_count;
94 /* Nonzero if we've hit a 'bad error', and should not write an obj file,
95 and exit with a nonzero error code. */
97 static int error_count;
99 int
100 had_errors (void)
102 return error_count;
105 /* Print the current location to stderr. */
107 static void
108 as_show_where (void)
110 char *file;
111 unsigned int line;
113 as_where (&file, &line);
114 identify (file);
115 if (file)
116 fprintf (stderr, "%s:%u: ", file, line);
119 /* Send to stderr a string as a warning, and locate warning
120 in input file(s).
121 Please only use this for when we have some recovery action.
122 Please explain in string (which may have '\n's) what recovery was
123 done. */
125 void
126 as_tsktsk (const char *format, ...)
128 va_list args;
130 as_show_where ();
131 va_start (args, format);
132 vfprintf (stderr, format, args);
133 va_end (args);
134 (void) putc ('\n', stderr);
137 /* The common portion of as_warn and as_warn_where. */
139 static void
140 as_warn_internal (char *file, unsigned int line, char *buffer)
142 ++warning_count;
144 if (file == NULL)
145 as_where (&file, &line);
147 identify (file);
148 if (file)
149 fprintf (stderr, "%s:%u: ", file, line);
150 fprintf (stderr, _("Warning: "));
151 fputs (buffer, stderr);
152 (void) putc ('\n', stderr);
153 #ifndef NO_LISTING
154 listing_warning (buffer);
155 #endif
158 /* Send to stderr a string as a warning, and locate warning
159 in input file(s).
160 Please only use this for when we have some recovery action.
161 Please explain in string (which may have '\n's) what recovery was
162 done. */
164 void
165 as_warn (const char *format, ...)
167 va_list args;
168 char buffer[2000];
170 if (!flag_no_warnings)
172 va_start (args, format);
173 vsnprintf (buffer, sizeof (buffer), format, args);
174 va_end (args);
175 as_warn_internal ((char *) NULL, 0, buffer);
179 /* Like as_bad but the file name and line number are passed in.
180 Unfortunately, we have to repeat the function in order to handle
181 the varargs correctly and portably. */
183 void
184 as_warn_where (char *file, unsigned int line, const char *format, ...)
186 va_list args;
187 char buffer[2000];
189 if (!flag_no_warnings)
191 va_start (args, format);
192 vsnprintf (buffer, sizeof (buffer), format, args);
193 va_end (args);
194 as_warn_internal (file, line, buffer);
198 /* The common portion of as_bad and as_bad_where. */
200 static void
201 as_bad_internal (char *file, unsigned int line, char *buffer)
203 ++error_count;
205 if (file == NULL)
206 as_where (&file, &line);
208 identify (file);
209 if (file)
210 fprintf (stderr, "%s:%u: ", file, line);
211 fprintf (stderr, _("Error: "));
212 fputs (buffer, stderr);
213 (void) putc ('\n', stderr);
214 #ifndef NO_LISTING
215 listing_error (buffer);
216 #endif
219 /* Send to stderr a string as a warning, and locate warning in input
220 file(s). Please us when there is no recovery, but we want to
221 continue processing but not produce an object file.
222 Please explain in string (which may have '\n's) what recovery was
223 done. */
225 void
226 as_bad (const char *format, ...)
228 va_list args;
229 char buffer[2000];
231 va_start (args, format);
232 vsnprintf (buffer, sizeof (buffer), format, args);
233 va_end (args);
235 as_bad_internal ((char *) NULL, 0, buffer);
238 /* Like as_bad but the file name and line number are passed in.
239 Unfortunately, we have to repeat the function in order to handle
240 the varargs correctly and portably. */
242 void
243 as_bad_where (char *file, unsigned int line, const char *format, ...)
245 va_list args;
246 char buffer[2000];
248 va_start (args, format);
249 vsnprintf (buffer, sizeof (buffer), format, args);
250 va_end (args);
252 as_bad_internal (file, line, buffer);
255 /* Send to stderr a string as a fatal message, and print location of
256 error in input file(s).
257 Please only use this for when we DON'T have some recovery action.
258 It xexit()s with a warning status. */
260 void
261 as_fatal (const char *format, ...)
263 va_list args;
265 as_show_where ();
266 va_start (args, format);
267 fprintf (stderr, _("Fatal error: "));
268 vfprintf (stderr, format, args);
269 (void) putc ('\n', stderr);
270 va_end (args);
271 /* Delete the output file, if it exists. This will prevent make from
272 thinking that a file was created and hence does not need rebuilding. */
273 if (out_file_name != NULL)
274 unlink_if_ordinary (out_file_name);
275 xexit (EXIT_FAILURE);
278 /* Indicate assertion failure.
279 Arguments: Filename, line number, optional function name. */
281 void
282 as_assert (const char *file, int line, const char *fn)
284 as_show_where ();
285 fprintf (stderr, _("Internal error!\n"));
286 if (fn)
287 fprintf (stderr, _("Assertion failure in %s at %s line %d.\n"),
288 fn, file, line);
289 else
290 fprintf (stderr, _("Assertion failure at %s line %d.\n"), file, line);
291 fprintf (stderr, _("Please report this bug.\n"));
292 xexit (EXIT_FAILURE);
295 /* as_abort: Print a friendly message saying how totally hosed we are,
296 and exit without producing a core file. */
298 void
299 as_abort (const char *file, int line, const char *fn)
301 as_show_where ();
302 if (fn)
303 fprintf (stderr, _("Internal error, aborting at %s line %d in %s\n"),
304 file, line, fn);
305 else
306 fprintf (stderr, _("Internal error, aborting at %s line %d\n"),
307 file, line);
308 fprintf (stderr, _("Please report this bug.\n"));
309 xexit (EXIT_FAILURE);
312 /* Support routines. */
314 void
315 sprint_value (char *buf, valueT val)
317 if (sizeof (val) <= sizeof (long))
319 sprintf (buf, "%ld", (long) val);
320 return;
322 if (sizeof (val) <= sizeof (bfd_vma))
324 sprintf_vma (buf, val);
325 return;
327 abort ();
330 #define HEX_MAX_THRESHOLD 1024
331 #define HEX_MIN_THRESHOLD -(HEX_MAX_THRESHOLD)
333 static void
334 as_internal_value_out_of_range (char * prefix,
335 offsetT val,
336 offsetT min,
337 offsetT max,
338 char * file,
339 unsigned line,
340 int bad)
342 const char * err;
344 if (prefix == NULL)
345 prefix = "";
347 if (val >= min && val <= max)
349 addressT right = max & -max;
351 if (max <= 1)
352 abort ();
354 /* xgettext:c-format */
355 err = _("%s out of domain (%d is not a multiple of %d)");
356 if (bad)
357 as_bad_where (file, line, err,
358 prefix, (int) val, (int) right);
359 else
360 as_warn_where (file, line, err,
361 prefix, (int) val, (int) right);
362 return;
365 if ( val < HEX_MAX_THRESHOLD
366 && min < HEX_MAX_THRESHOLD
367 && max < HEX_MAX_THRESHOLD
368 && val > HEX_MIN_THRESHOLD
369 && min > HEX_MIN_THRESHOLD
370 && max > HEX_MIN_THRESHOLD)
372 /* xgettext:c-format */
373 err = _("%s out of range (%d is not between %d and %d)");
375 if (bad)
376 as_bad_where (file, line, err,
377 prefix, (int) val, (int) min, (int) max);
378 else
379 as_warn_where (file, line, err,
380 prefix, (int) val, (int) min, (int) max);
382 else
384 char val_buf [sizeof (val) * 3 + 2];
385 char min_buf [sizeof (val) * 3 + 2];
386 char max_buf [sizeof (val) * 3 + 2];
388 if (sizeof (val) > sizeof (bfd_vma))
389 abort ();
391 sprintf_vma (val_buf, (bfd_vma) val);
392 sprintf_vma (min_buf, (bfd_vma) min);
393 sprintf_vma (max_buf, (bfd_vma) max);
395 /* xgettext:c-format. */
396 err = _("%s out of range (0x%s is not between 0x%s and 0x%s)");
398 if (bad)
399 as_bad_where (file, line, err, prefix, val_buf, min_buf, max_buf);
400 else
401 as_warn_where (file, line, err, prefix, val_buf, min_buf, max_buf);
405 void
406 as_warn_value_out_of_range (char * prefix,
407 offsetT value,
408 offsetT min,
409 offsetT max,
410 char * file,
411 unsigned line)
413 as_internal_value_out_of_range (prefix, value, min, max, file, line, 0);
416 void
417 as_bad_value_out_of_range (char * prefix,
418 offsetT value,
419 offsetT min,
420 offsetT max,
421 char * file,
422 unsigned line)
424 as_internal_value_out_of_range (prefix, value, min, max, file, line, 1);